Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE
Updated: 1 hour 32 min ago

QML Online - Qt 5.15, Kirigami, Breeze and more!

9 hours 10 min ago

I'm happy to announce that QML Online is now running with the last version of Qt (5.15) and with an initial Kirigami integration with breeze icons!

There is also a couple of updates for quality of life, like:

  • HTML fixes/corrections
  • Better integration with Firefox
  • New Qt version information label
  • Support for QtQuick.XmlListModel

But sadly, with new features we do have new bugs! As I said before, the Kirigami integration is an initial version, there are some know bugs with it, like:

  • OverlayDrawer has a transparent background (the issue appears to be common in low performance environments)
  • Kirigami version is a bit old (v5.70), newer versions need Qt future feature for QFuture and friends
What is next

I'll be working closer with Kirigami to fix these bugs, and the new feature of multiple instances of QML Online on the same webpage will be in hold for now.

As a reminder, please be free to send Merge Requests, feature requests, opinions and issues.

Thanks

I would like to thank all users of QML Online, and the people that are sending kind works about how it's improving their workflow and how useful the tool is! That really helps to move the project forward.

KDE neon Rebased on 20.04

12 hours 10 min ago

KDE neon is our installable Linux with continuous integration and deployment. It’s based on Ubuntu who had a new Long Term Support Release recently so we’ve rebased it on Ubuntu 20.04 now.

You should see a popup on your install in the next day or so. It’ll ask you to make sure your system is up to date then it’ll upgrade the base to 20.04 which takes a while to download and then another while to install.

Afterwards it should look just the same because it’s the same wonderful Plasma desktop.

Upgrade Instructions

The installable ISOs are also updated and this time they all use the Calamares installer.

Testing and Unstable edition, these are built from the soon-to-be-released Git branches and the untested Git branches. Alas trying the installable ISOs today we found some bugs in the Git Calamares installer so they’re not published yet but the upgrader will still popup on existing installs. Update these are up now

We implemented OEM install mode in Calamares so the other way to get neon is to buy a KDE Slimbook III and it’ll use that.

We also implemented a full disk encryption tickbox in Calamares.

The Docker images are still to be updated and the Snap packages also need moved over.

Old truths remain

Sunday 9th of August 2020 10:00:00 PM

This week I was going through the locale module in Calamares, bumped into a odd combination of new and deleteLater(), and something started nagging; that code can be better. I first did the “obvious” and moved things to the stack (er .. automatic storage duration) and then asked around, and in 2009 Frank Osterfeld blogged exactly about my problem, and explained that I’d done exactly the wrong thing.

Read Frank’s original on crashing KDE applications through modal dialogs, because he explains it very well.

Why do I bring this up? It’s old hat. Yesterday’s news. Common knowledge. Basic stuff everyone should know.

The thing is, common knowledge is kind of uncommon, and since senior developers don’t know everything, it’s worth repeating that kind of knowledge now-and-again.

Speaking of, at Akademy 2020 there will be a talk about this kind of old institutional knowledge. Tune in to Kevin on the last day of the conference.

KPhotoAlbum 5.7.0 out now

Sunday 9th of August 2020 07:33:00 AM

We’re pleased to announce a new release of KPhotoAlbum, the KDE photo management software! This time, it’s mostly a maintenance release with a lot of code cleanup and bug fixes. Nevertheless, there are also some changes and new features. In detail:

Enhancements/Features/Changes
  • Custom color schemes: Most notably, we added support for custom color schemes. KPhotoAlbum now also has a “Dark Mode”: Comparison: Light and Dark Theme

    Note: This feature replaces the custom background color for the thumbnail view.

  • Image search: We now offer experimental options for image search tuning.

  • Thumbnails: We added the new CLI utility kpa-thumbnailtool to manage KPA’s thumbnail cache. The cache now also contains the thumbnail size. Please notice that after the thumbnail cache was converted to the new format, older versions of KPhotoAlbum can no longer read it!

  • Privacy lock: The fake password-protection has been removed from privacy lock. Even with the warning message it might give somebody a false sense of security.

  • HTML export: HTML export themes missing a name are no longer displayed.
Bugfixes

In addition to other bugfixes, these have been addressed in the new release:

  • Make sure tag groups are always added to tag list as well (Fixes #423334).

  • Fixed handling of negation in searches (Fixes #334672).

  • Fix crash when dragging an image beyond the last thumbnail (Fixes #418251).

  • Fixed crash when ffmpeg can’t extract video thumbnails (Fixes #422555).

  • Removing a token no longer makes it disappear from the annotation dialog (Fixes #423978).

  • Sanitize input for the Tokens category, make Folder and Media Type categories read-only (Fixes #423979).
    We now have three types of list selects:

    "Normal" editable category (left), category that can only be selected (middle), read-only category (right)

The complete list of changes and fixes is listed in the ChangeLog.

Distribution-specific changes

This may be of interest esp. for the distributors:

  • Marble/libkgeomap: We no longer use Digikam’s libkgeomap to display geographic information and map views. Instead, we now utilize Marble directly.

  • KIPI plugins: The support for KDE’s KIPI plugins has been removed in favor of the new Purpose infrastructure.

  • Python 2: KPhotoAlbum’s Python 2 API has been dropped, along with all associated Python 2 scripts.

  • Qt 5.15: KPA’s code has been widely reworked and modernized (esp. speaking of using C++11 features instead of their old Qt macro counterparts) and now compiles again warning-free with Qt 5.15.

Thanks to everybody involved

According to git, the following individuals did commits this time (in alphabetical order):

  • Yuri Chornoivan
  • Robert Krawitz
  • Tobias Leupold
  • Jesper K. Pedersen
  • Johannes Zarl-Zierl

Thanks a lot to everybody having put work in this release!

— Tobias

Senior Developers don’t know Everything

Saturday 8th of August 2020 10:00:00 PM

For about 20 years, I’ve been doing C++ and Qt and KDE development. I suppose that makes me a “senior software engineer”, also in the sense that I’ve hacked, programmed, futzed, designed, architected, tested, proved-correct, and cursed at a lot of software. But don’t let the label fool you: I look up just as much in the documentation as I ever did; senior developers don’t know everything.

Documentation I looked up today:

Some of that documentation is going to remain fresh in my mind for a bit, some is going to be forgotten almost immediately (like the JSON schema bits: I need it to write a schema, but the schema is write-and-forget because automatic tools take over from there at least until the schema needs a change, which could be over a year from now).

None of this information is essential to my work as a developer as long as I know how to look it up, and can do so quickly and effectively: trivia knowledge is not a measure of developer worthyness.

So, you know, if you’re interviewing for a job position and get quizzes on this kind of things, then there are two possibilities:

  • the job is all about doing-this-one-thing, in which case the knowledge is necessary and yes, knowing it already is a thing, or
  • this is an incidental, once-a-year item where gatekeeping over it is unadulterated cow poop (from which, I learned this week, you can distill vanilla aroma).

Keep learning, but don’t be afraid to forget.

How to rock: First tips

Saturday 8th of August 2020 08:28:00 AM

After working for some time collaborating with open source/free software projects, I started to help newcomers to contribute and push the development further with good practices.

This post will try to itemize some important tips that can be used for software collaboration and personal projects, hopefully it'll help you to have a solid ground of good practices and advices for your contributions in a project. It contains information abut good code practices, a simple guide of helpful API design, code organization, comments, naming variables, development flow and self-criticism. Please enjoy, and any feedback (including critics) is much appreciated!

Code practices
  • Encapsulate magic variables:

    ...// First version start_communication(0, 1, 232); // Reviewer: What is the meaning of 0 ? What is 1 ? Why 232 ? ...// Second version enum class Messages { ... RequestStatus = 232, } ... const uint8_t vid = 0; const uint8_t cid = 1; start_communication(vid, cid, Messages::RequestStatus); // Reviewer: What is vid ? What is cid ? ...//Final version ... const uint8_t vehicle_id = 0; const uint8_t component_id = 1; start_communication(vehicle_id, component_id, Messages::RequestStatus);

    As you can see, the final version makes everything more readable, we know that we are starting the communication with a vehicle that has an id of 0 and the vehicle probably contains a component with id 1, and while calling this function we are also requesting the status. Much better than 0, 1 and 232 right ? Doing this will help the reviewers and future developers to understand what is the meaning of such numbers. It's also necessary to avoid variables that contains only single letters or really short abbreviations, is much harder to understand this: $$C^2 = A^2 + B^2$$ over this: $$hypotenuse^2 = catheti_1^2 + catheti_2^2$$

  • Avoid multiple arguments:

    ...// First version auto vehicle = new Vehicle( VehicleType::Car, 4, {28, 31}, Fuel::Electric, 1.2, 613 ); // Reviewer: What is the meaning of all this values ? // How can we make it better ? ...// Second version auto vehicle = new Vehicle(VehicleType::Car) vehicle->setNumberOfTires(4); vehicle->setTirePressure({28, 31}); vehicle->setFuel(Fuel::Electric); vehicle->setWeightInTons(1.2); vehicle->setAutonomyInKm(613); ...// It's also possible to use aggregate initialization in C++20 // and user-defined literals from C++11 auto vehicle = new Vehicle({ .type = VehicleType::Car, .numberOfTires = 4, .tirePressure = {28_psi, 31_psi}, .fuel = Fuel::Electric, .weight = 1.2_tn, .autonomy = 613_km, });

    Both second and C++20/C++11 alternatives are valid for a better readability of the code, to choose between both alternatives will depend of how are you going to design your API, probably if you are more familiar with the Qt API, the second version appears to be the most common, the C++20/C++11 alternative appears to be a bit more verbose but can be useful to avoid multiple function calls and helpful when dealing with a simpler code base.

  • Encapsulate code when necessary, try to break functions in a more readable and explanatory way:

    ...// Original version void Serial::start_serial_communication() { // Check if we are open to talk if (!_port || _port->register() != 0xb0001) { log("Serial port is not open!"); return; } // Send a 10ms serial break signal _port->set_break_enabled(true); msleep(10); _port->set_break_enabled(false); usleep(10); // Send intercalated binary for detection _port->write('U'); _port->flush(); // Send start AT command _port->write("AT+start"); } // Reviewer: Try to make it more readable encapsulating // some functionalities ...// Second version bool Serial::is_port_open() { return !_port || _port->register() != 0xb0001; } void Serial::force_baudrate_detection() { // Send a 10ms serial break signal _port->set_break_enabled(true); msleep(10); _port->set_break_enabled(false); usleep(10); // Send intercalated binary for detection _port->write('U'); _port->flush(); } void Serial::send_message(Message message_type) { _port->write(messageFromType(message_type)); } void Serial::start_serial_communication() { if (!is_port_open()) { log("Serial port is not open!"); return; } force_baudrate_detection(); send_message(Message::Start) }

    As you can see, the reason behind each block of code is clear now, and with that, the comments are also not necessary anymore, the code is friendly and readable enough that's possible to understand it without any comments, the function name does the job for free.

  • Avoid comments, that's a clickbait, comments are really necessary, but they may be unnecessary when you are doing something that's really straightforward, and sometimes when something isn't, it's better to encapsulate it.

    ...// Original version void blink_routine() { // Use the LED builtin const int led_builtin = LED_BUILTIN; // Configure ping to output setPinAsOutput(led_builtin); // Loop forever while(true) { // Turn the LED on turnPinOn(led_builtin); // Wait for a second wait_seconds(1); // Turn the LED off turnPinOff(led_builtin); // Wait for a second wait_seconds(1); } }

    Before checking the final version, let me talk more about it:

    • For each line of code you'll have a comment (like a parrot that repeat what we say), and the worst thing about these comments is that the content is exactly what you can read from the code! You can think that this kind of comment is dead code, something that has the same meaning as the code, but it does not run, resulting in a duplicated amount of lines to maintain. If you forget to update each comment for each line of code, you'll have a comment that does not match with the code, and this will be pretty confuse for someone that's reading it.

    • One of the most important skills about writing comments, is to know when not to write it!

    • A comment should bring a value to the code, if you can remove the comment and the code can be understandable by a newcomer, the comment is not important.

    ...// Final version void blink_routine() { const int led_builtin = LED_BUILTIN; setPinAsOutput(led_builtin); while(true) { turnPinOn(led_builtin); wait_seconds(1); turnPinOff(led_builtin); wait_seconds(1); } }

    There is a good video about this subject by Walter E. Brown in cppcon 2017, "Whitespace ≤ Comments << Code".

    And to finish, you should not avoid comments, you should understand when comments are necessary, like this:

    // From ArduPilot - GPIO_RPI void set_gpio_mode_alt(int pin, int alternative) { // **Moved content from cpp for this example** const uint8_t pins_per_register = 10; // Calculates the position of the 3 bit mask in the 32 bits register const uint8_t tree_bits_position_in_register = (pin%pins_per_register)*3; /** Creates a mask to enable the alternative function based in the following logic: * * | Alternative Function | 3 bits value | * |:--------------------:|:------------:| * | Function 0 | 0b100 | * | Function 1 | 0b101 | * | Function 2 | 0b110 | * | Function 3 | 0b111 | * | Function 4 | 0b011 | * | Function 5 | 0b010 | */ const uint8_t alternative_value = (alternative < 4 ? (alternative + 4) : (alternative == 4 ? 3 : 2)); // 0b00'000'000'000'000'000'000'ALT'000'000'000 enables alternative for the 4th pin const uint32_t mask_with_alt = static_cast<uint32_t>(alternative_value) << tree_bits_position_in_register; const uint32_t mask = 0b111 << tree_bits_position_in_register; // Clear all bits in our position and apply our mask with alt values uint32_t register_value = _gpio[pin / pins_per_register]; register_value &= ~mask; _gpio[pin / pins_per_register] = register_value | mask_with_alt; }

    Mostly of the lines in this code can be impossible to understand without access or reading the datasheet directly, the comments are here to understand what is going on and why, otherwise anyone that'll touch this code will need to do a reverse engineer to understand it.

Development flow
  • Avoid creating multiple Pull Requests (PRs), update the ones that are still open.

    • E.g: You created a Pull Request called "Add button feature", some modifications will be necessary after the review process, and for that you'll need to update the same branch over creating new ones. That's necessary to help the project maintainers to see previous comments and the development history. Creating multiple PRs will only make the maintainers confuse and unable to track old comments, suggestions and your code changes between PRs.
  • Create atomic and self-contained commits, avoid doing multiple tasks in the same commit.

    • E.g: You created a commit to fix the serial communication class, and inside the same commit you are doing 3 different tasks, removing trailing spaces, fixing a pointer validation check and a typo in the documentation of a different class. This appear to be silly and bureaucratic, but there are good reasons to break this simple commit and at least 3 different commits, one for the pointer check, a second one for the typo and a third one for the trailing space.

      Developers usually track lines history to understand the changes behind a functionality, it's common to search with grep history from commits or line changes in specific commits to understand the history of a library, function, class, or a small feature, if the commits start to be polluted with unnecessary changes, this development practice will be almost impossible to be done, since a bunch of unrelated lines will me changed between commits and this technic will be unable to help the dear developer. git blame will also be of little help.

      The example was also really simple, but you can imagine what happens if you change different parts of the code, for unrelated things, and a bug appears, technics such as git bisect will still work, but the result will be much harder to understand and to find which line is the one that created such bug.

  • Create atomic and self-sustained PRs, avoid doing multiple things in the same PR, like different features. They may appear simple with small pieces of code/functionality but they can escalate quickly after a review process, and if both features are somehow related or dependently, it's recommended to break it in multiple PRs with code to maintain compatibility with current code base.

    • E.g: You have applied a PR for software notifications, and somehow you also added a URL fetch functionality to grab new software versions from the server. After the first review, the maintainer asks to create a more abstracted way to fetch data from a REST API and to deal with network requirements, this will start to convolute the PR, moving the initial idea of the notification feature to an entire network REST API architecture. With that, it's better to break the PR in two, one that only provides the notification and a second PR that is used for the REST API related code.
  • Do your own review, the final and probably most important tip of all, doing that will train your mind and eyes to detect poor code standards or bad practices, it'll also make your PR be merged easily and faster, since you'll be able to catch problems before the reviewer feedback. Some reviewers may think that reviewing your own PR is a must, since we are talking about open source projects and free software, you should understand that the people that are reviewing your code are not obligated to do so, the majority are collaborating and donating their own time to help the development and maintenance of such projects, doing your own review is a sign of empathy about the project and maintainer time.

Final comment

This is the first post of a series that I'm planning to do. Hope that some of these points may help you in your journey.

References

This week in KDE: window thumbnails on Wayland

Saturday 8th of August 2020 05:27:43 AM

This week we got tons and tons of stuff done, including window thumbnails on Wayland! This much-awaited feature brings our Wayland session ever closer to parity with the X11 session. But wait, there’s more:

New Features

Konsole now lets you configure how dark inactive terminals become when using the “darken inactive terminals” feature (Tomaz Canabrava, Konsole 20.12.0)

Task Manager window thumbnails now work on Wayland! (Aleix Pol Gonzalez, Plasma 5.20)

Discover can now be used to perform updates of content downloaded through the Get New Stuff dialogs (Dan Leinir Turthra Jensen, Plasma 5.20)

Plasma applets now feature an “About” page in their settings windows (David Redondo, Plasma 5.20)

Kate and other KTextEditor-based apps now show a zoom indicator in the status bar when the current zoom level is not 100% (Jan Paul Batrina, Frameworks 5.74)

Bugfixes & Performance Improvements

Opening an audio file from the filesystem in Elisa from Dolphin or KRunner or another app now works (Matthieu Gallien, Elisa 20.08.0)

Switching screens while in Okular’s Presentation Mode now works (David Hurka, Okular 20.08.0)

Fixed a case where KWin could crash when logging out of a Wayland session (Andrey Butirsky, Plasma 5.20)

In a Plasma Wayland session, XWayland no longer brings down the whole session when it crashes; it just restarts normally (Vlad Zahorodniy, Plasma 5.20)

Changing the list of active KRunner plugins now takes effect immediately rather than requiring KRunner to be restarted (Alexander Lohnau, Plasma 5.20)

The Search widget now respects the current list of active KRunner plugins (Alexander Lohnau, Plasma 5.20)

The mouse cursor no longer sometimes gets stuck when using screen rotation on Wayland (Aleix Pol Gonzalez, Plasma 5.20)

Edge swipe gestures and showing a hidden panel by tapping the screen edge now work on Wayland (Xaver Hugl, Plasma 5.20)

Adding a new network interface no longer messes up the display in the Networks system monitor (David Edmundson, Plasma 5.20)

Changing the systemwide scale factor now invalidates the Plasma SVG cache, causing SVG-based user interface elements throughout Plasma to be re-drawn with the correct scale, which should fix a wide variety of minor graphical glitches seen after changing the scale factor (David Edmundson, Frameworks 5.74)

The Baloo file indexer now skips files that repeatedly fail to index rather than repeatedly trying to re-index them anyway and failing in a loop that trashes your CPU (Stefan Brüns, Frameworks 5.74),

User Interface Improvements

When applying a tag to a file in Dolphin, if the tags menu only had one item in it, it now automatically closes after applying the tag (Ismael Asensio, Dolphin 20.08.0)

The current date is now shown in the Digital Clock applet by default (Claudius Ellsel, Plasma 5.20)

Animation speeds throughout the Breeze Widgets and Decoration themes now respect the global animation speed (Martin Sandsmark and Marco Martin, Plasma 5.20)

It’s now possible to do multiplication in KRunner using “x” as the multiplication operator, not just “*” (Alexander Lohnau, Plasma 5.20)

KRunner now shows tooltips for entries that don’t entirely fit, so you now have a way to read the dictionary text (Alexander Lohnau, Plasma 5.20)

And yes, multi-line output is coming soon as well

Kubuntu 20.04.1 has been released today, featuring the beautiful KDE Plasma 5.18 LTS

Friday 7th of August 2020 08:47:40 PM

The Kubuntu Team is happy to announce that Kubuntu 20.04.1 LTS “point release” is available today, featuring the beautiful KDE Plasma 5.18 LTS: simple by default, powerful when needed.

As usual, this point release includes many updates, and updated installation media has been provided so that fewer updates will need to be downloaded after installation. These include security updates and corrections for other high-impact bugs, with a focus on maintaining stability and compatibility with Kubuntu 20.04 LTS.

More details can be found in the release notes: https://wiki.ubuntu.com/FocalFossa/ReleaseNotes/Kubuntu

In order to download Kubuntu 20.04.1 LTS, visit:

Download Kubuntu

Users of Kbuntu 18.04 LTS will soon be offered an automatic upgrade to 20.04.1 LTS via Update Manager/Discover. For further information about upgrading, see:

https://help.ubuntu.com/community/FocalUpgrades

As always, upgrades to the latest version of Kubuntu are entirely free of charge.

We recommend that all users read the 20.04.1 LTS release notes, which document caveats and workarounds for known issues, as well as more in-depth notes on the release itself. They are available at:

https://wiki.ubuntu.com/FocalFossa/ReleaseNotes

If you have a question, or if you think you may have found a bug but aren’t sure, you can try asking in any of the following places:

#kubuntu on irc.freenode.net
https://lists.ubuntu.com/mailman/listinfo/kubuntu-users
https://www.kubuntuforums.net/
https://www.reddit.com/r/Kubuntu/

Linux App Summit Goes Online in November

Wednesday 5th of August 2020 04:36:24 PM



Once again, KDE and GNOME are teaming up to bring you THE conference for people interested in establishing Linux as a great end-user platform. At the Linux App Summit we work on making app creation for users easy and worthwhile.

Since travel is complicated nowadays, we decided to make LAS 2020 a virtual conference. The event will open Thursday, 12th November and we'll wrap up on Saturday, 14th November. Our goal is to engage people in multiple time zones and make the content available online after the conclusion.

The Call for Talks is now open! Please take a look at the suggested topics and send in your ideas. We encourage new speakers, so don’t hesitate to submit a proposal!

Save the date on your calendar and we look forward to seeing you at LAS 2020!

Learn more about LAS 2020.

Important Dates:
  • Call for Papers opens: Today!
  • Call for Papers closes: September 15th
  • Speakers announced: October 1st
  • Conference: November 12th to November 14th

KBibTeX 0.10-alpha2 aka 0.9.81

Wednesday 5th of August 2020 03:32:47 PM

The release of KBibTeX 0.10 is approaching with the release of KBibTeX 0.10-alpha2 aka 0.9.81.

Improvements and changes since 0.9.2 are less on the user interface, but on the code behind it:

Read more... )

Many thanks go to contributors such as bug reporters, translators, and everyone else who contributed to KBibTeX!

Source code is available as tar ball, cryptographically signed using GnuPG key 1808CB466328F4380685A3B1A264FD738D861F41.



comments

The structure of KDE, or how anarchy sometimes works

Tuesday 4th of August 2020 06:09:03 PM

KDE is a funny beast. In a lot of ways, it’s an anarchic society that actually works!

Engineers and designers work on KDE software and websites, but none of them are paid by KDE itself. Most are volunteers but some (myself included) are paid by 3rd-party companies. These people work on what they want or what they are sponsored by their company to work on, not what anyone in KDE tells them to work on.

KDE has a board of directors, but they are elected by KDE’s membership rather than stockholders (there is no stock lol), and they do not control KDE’s strategic direction as in a corporation. Rather, they mostly take care of financial and legal matters, sort out copyright claims, help to organize the yearly Akademy conference, and so on.

There is no formal “upper management” or even “middle management” layer. We have the “gardening team” whose members are in essence volunteer managers, but we mostly do things like triaging bugs, following up on stuck merge requests, performing QA on unreleased software, and so on. We support the people doing the work, rather than telling them what to do.

So how does anything get done around here?!

Well, just because KDE is an anarchy, does not mean that there is no organization and coordination! It’s just all done on a voluntary basis, with slightly unusual motivation techniques. Anarchy is not the absence of governance and decision-making, it’s just different from how it’s typically done.

In a corporation, managers motivate their employees by offering them them money, benefits, bonuses, promotions, and internal social perks. Bad work or bad behavior is punished by reprimands, demotion, or being fired.

But in KDE, most people are unpaid volunteers, so KDE has no financial leverage over them. Those who are paid are hired by 3rd-parties rather than KDE itself. Neither the carrot nor the stick will work!

Instead, motivation within KDE uses the currency of excitement. When a project is cool and its contributors publicly demonstrate its coolness and their enthusiasm for it, other people want to join in and help out! This turns out to be a very effective way to motivate free people to work on something: you make them feel like they want to be a part of something big and special, and you organize the discussion in a way that makes them feel like they can be included.

KDE’s design team (the VDG group) does a lot of this, constantly churning out astonishingly beautiful mockups and organizing discussions about important topics. People gravitate to the VDG’s proposals because they seem cool and there’s buzz and excitement surrounding it. The promo team works to generate that buzz and excitement. Other teams do similar things. You have to keep people excited and happy or else they will drift away.

This leads to an important point: you have to minimize negativity! For most people, conflict destroys energy and motivation. Internal arguments and politics need to be minimized and driven towards a consensus rather than simmering forever. Even if you have to bend a bit and give up some of what you want, that’s a better option than getting nothing because everyone is burned out by endless arguing. And new contributors in particular must be treated with kindness, given the benefit of the doubt, and made to feel welcome.

Similarly, if you’re a user who’s frustrated with the lack of progress on something you care about, insulting the developers or KDE itself in the bug report is the worst thing you could do: it will damage the motivation of the people in a position to do the work, reducing the chance that you will get what you want. Gently pinging people without negativity is the way to go–or even better, work on it yourself! Like all FOSS projects, KDE encourages self service.

Announcing Krita’s Scripting School!

Tuesday 4th of August 2020 12:13:40 PM

In 2018, we reintroducted scripting to Krita. Unlike our previous attempts to provide scripting, this time it took off! People are making all kinds of useful and fun extensions for Krita. Like a new color picker and mixer, a plugin to modify the way Krita’s subwindows are handled, new toolboxes, integration with other applications like Autodesk Shotgun,

But what was missing was a good overview of the various areas that could be scripted. Tutorials and example code on how to use the scripting API in bite-size chunks. The regular API documentation is generated automatically from the APIDOX comments. It is a good reference but can be difficult to understand since it is generated from the C++ code that provides the scripting bindings.

Scott Petrovic, Krita’s UX designer and website maintainer, created a fresh new tutorial website: Scripting with Krita:

Scripting with Krita

And there are not just the lessons teaching you about creating scripts, running them, using the Krita scripting API and how to develop plugins, there are also really useful overviews of the actions your script can trigger and the icons you can use!

The post Announcing Krita’s Scripting School! appeared first on Krita.

Plasma Browser Integration 1.7.6

Tuesday 4th of August 2020 07:00:00 AM

I’m pleased to announce the immediate availability of Plasma Browser Integration version 1.7.6 on the Chrome Web Store as well as Firefox Add-Ons page. This release comes with a few bug fixes, performance improvements, and translation updates.

Konqi surfing the world wide web

Plasma Browser Integration bridges the gap between your browser and the Plasma desktop. It lets you share links, find browser tabs in KRunner, monitor download progress in the notification center, and control music and video playback anytime from within Plasma, or even from your phone using KDE Connect!

What’s new?

(also see the Changelog Page on our Community Wiki)

Detecting camouflaged Chromium-based browsers

Chromium-based browsers such as Vivaldi and Brave have recently changed their user agents to match that of regular Chrome to avoid being spuriously blocked. However, this also meant that media controls and other extension features were mapped to Chrome instead. This has been addressed by also checking our parent process – something a website can’t so, so you’ll still be impersonating a “proper” Chrome on the web. If there’s any other Chrome-based browser you want to see explicitly supported, let us know!

Better video iframe handling

The extension is loaded into every website as well as its iframes. When navigating away from the page that is currently playing, media controls will be rescinded. Due to a bug this did not work for iframes, leading to a popuplar bug where Plasma would show ghost videos playing on pages like Tweetdeck.

Moreover, the website’s DOM is also monitored to notice when a player is dynamically added or removed, for instance when a video overlay opens or closes. Unfortunately, this monitoring can be quite expensive and became a bottleneck on pages with lots of dynamically loaded content like is the case when viewing a large merge request on KDE’s GitLab instance. This release significantly improves performance here.

Improved media controls

As usual, this release brings some improvements to media controls. Short sounds and videos are currently ignored to avoid trying to control e.g. a “new message” sound or short hover video previews. However, some live stream implementations don’t report the correct duration of Infinity but gradually fill up their time bucket every few seconds. Previously, the extension only checked duration once to determine whether to provide media controls. With this update duration is continuously checked and media controls would become available eventually.

Furthermore, for websites that do not set album art through Media Session API, the video player’s poster is now used as album cover. This is the cover image that is often shown when the video isn’t playing.

QML Online - Can be everywhere!

Monday 3rd of August 2020 06:59:39 PM

A new feature of QML Online is already available, allows it to run in any site/blog with minimal js/html code!

Hopefully, our experience with QML examples, tutorials and documentation should change in the near future.

Ff you don't know what QML Online is, please take a look in my previous posts:

What are we talking about ?

QML Online now can be used in any blog or website without much work, like this:

import QtQuick 2.7 import QtQuick.Controls 2.3 import QtQuick.Layouts 1.12 Rectangle { color: "#179AF3" anchors.fill: parent ColumnLayout{ anchors.bottom: parent.bottom anchors.right: parent.right CheckBox { checked: true text: "Check this!" } CheckBox { text: "Or this!" } } Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } } --> const qmlonline = new QmlOnline("qmlonline") qmlonline.registerCall({ qmlMessage: function(msg) { console.log(`qml message: ${msg}`) }, qmlError: function(data) { console.log(`qml message: ${JSON.stringify(msg)}`) }, posInit: function() { qmlonline.setCode(`import QtQuick 2.7 import QtQuick.Controls 2.3 import QtQuick.Layouts 1.12 Rectangle { color: "#179AF3" anchors.fill: parent ColumnLayout{ anchors.bottom: parent.bottom anchors.right: parent.right CheckBox { checked: true text: "Check this!" } CheckBox { text: "Or this!" } } Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } }`) }, }) qmlonline.init()

And how can this new feature be used ?

It's quite simple, check this minimal HTML example:

<html> <head> <title>Qml Online minimal example</title> </head> <body> <script type="text/javascript" src="https://qmlonline.kde.org/qtloader.js"></script> <script type="text/javascript" src="https://qmlonline.kde.org/qml.js"></script> <div id="qmlonline"></div> <script type='text/qml'> import QtQuick 2.7 import QtQuick.Controls 2.3 Rectangle { color: "#179AF3" anchors.fill: parent Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } } </script> <script type='text/javascript'> const qml = new QmlOnline("qmlonline") qml.registerCall({ qmlMessage: function(msg) { console.log(`qml message: ${msg}`) }, qmlError: function(data) { console.log(`qml error: ${JSON.stringify(data)}`) }, posInit: function() { qml.setCode(Array.prototype.slice.apply(document.getElementsByTagName('script')).find(e => e.type == 'text/qml').text) }, }) qml.init() </script> </body> </html>

As you can see, there is three steps, include both qtloader.js and qml.js, add a div DOM and create a QmlOnline object. Since I'm not a web expert, probably there is a better way to organize this approach for the user and bugs may exist. Be free to create Merge Requests, or get in touch with feature requests and issues.

What is next ?

From my planned objectives, sharing QML Online as library to be available for any website was one of the final points, the only one that's still missing is the Kirigami support, that's still in progress and hopefully will be finished until the end of the year (if everything goes fine).

There is also a small bug, where it's not possible to use multiple QML Online instances on the same webpage.

MyPaint Brush Engine [Final Phase]

Monday 3rd of August 2020 09:45:00 AM
We are in the final phase of GSoC. I don't even remember how quickly the last two months flew by. Coming to my project, it is almost complete apart from some finalisation related stuff that still is remaining. Perhaps, some review changes that my mentors shall give me once my current patch has been reviewed are also remaining.
This month, (20 days remaining before the final submissions start actually) I need to complete two items:
  1. Refactorizing the plugin for master branch: There were a lot of changes in master due to the complete resource-rewrite. Because of this, I need to change my way of handling mypaint brush files (.myb files) in master. This requires a bit of refactorization. I am afraid its been a while since I have seen the master and don't what changes I need to do to make this plugin work in master. I just hope it does not turn out to be something complex.
  2. User Documentation: Apart from refactorization, I need to start with writing user documentation ASAP. The advanced mypaint brush settings don't make much sense to me though, that might cause a bit trouble. I don't know what to write for those. Will require some help for this from my mentors I guess.
I don't know why, but I always seem to have this feeling at the back of my head that something will come up that will be tough to handle and ruin my project. Though this has been happening even before GSoC started. That scares me a bit :( Anyways.
Good bye :)

GSoC'20 progress : Phase II

Sunday 2nd of August 2020 06:30:00 PM
Work progress during the second phase of Google Summer of Code

Latte Dock v0.10~ | July Update

Sunday 2nd of August 2020 01:35:00 PM

Hello everyone,

in the following you can read July development news from Latte Dock v0.10~ git version. [~, stands for rapid development, in your distro package repos is mentioned as git version]

Contents;

1. New Auto Hide Sidebar visibility mode
Thanks to Martijn Vogelaar a new visibility mode for sidebars is supported. The new mode triggers Latte panel showing/hiding through the Latte Sidebar Button applet and global shortcuts but at the same time if the panel does not contain mouse for a period of time (can be set from Show timer) then it auto hides itself.
Visibility modes in general have updated their organization in order to be grouped much better. Currently they look like:


- visibility modes organization -


2. Background with All Corners

Users can now force background corners at all cases. I suppose this could be helpful if someone wants to replicate ChromeOS layout or play with different appearance styles.
- chromeos layout possibilities -


- all corners option in background -


3. Memory Consumption

A lot of improvements have been implemented in that regard. All Edit Mode windows (Canvas window, Main Settings with Behavior/Apperarance/Effects, Secondary small window) are now created only first time called and afterwards are reused for ALL Views (docks/panels) when requested. Because of this you are going to notice a very big memory usage drop when editing your panels and docks compared to any previous Latte version.
Even more, Indicators Config UIs found at Effects page are also following the new rule (create only once and reuse afterwards). In the past, indicators config uis were recreated its time a View was requesting editing. Because of that change I notice very stable memory usage that does not increase/decrease all the time when showing editing windows.
I think that the best way to calculate Latte memory consumption in v0.10~ is the following. Create your panels and docks the way you like them and change their properties and appearance to your liking. Close Latte afterwards and restart it. Start using your docks and panels by triggering popups, parabolic effect etc. Afterwards notice your memory usage but make sure that you have not triggered any docks/panels editing.

4. Layout Details Window

I am pretty proud of the new Layout Details window found in Layout Editor. With the new window you can add icons and backgrounds to your layouts in very nice and user friendly manner.
- layout details window / choose background color -


5. Layout Background Badges

- background badges -

When playing with Layouts in the editor it is nice to distinguish your different layouts fast and easy. Icons, colors and backgrounds are helping with this. Background badges take up the task and they are identified with the following priority:
   a. Layout icon is always preferred if it has been set by the user
   b. Layout assigned Plasma Activities icons are used if there is no layout icon
   c. Canvas Background is used there is no layout icon and that layout is not assigned to any activities
That was possible because layouts in the Editor are provided through QTableModel that has made the implementation pretty concrete and future proof.







6. Noteworthy Fixes

  • When a layout was deleted from Layouts Editor there were cases that could break the layouts model data validity.
  • Loading/Unloading different layouts could create a crash pointing in plasma frameworks because some codepaths were trying to access applets() that had already been destroyed.
  • Enable Hide Timer for ZERO value [instant use]
  • Enable dock/panel hiding only after any slide-in event has finished
  • Fix Panel/Dock types enforcement through Editing windows
  • Live Editing mode at all times even when "Rearranging and Configuring Applets". Latte is auto-adjusting dock and panel modes based on different user preferences immediately after such changes occur.
  • fix vertical system trays appearance for Plasma >= 5.19
  • Support XCB::SHAPE in order to define which dock areas are accepting mouse input and for all the rest input is forwarded to underlying windows [case of client sided background shadows used in docks].
  • Support GTK_FRAME_EXTENTS in order to define which dock areas are actually really used from docks and ignore all the rest. This way the compositor is informed about docks real geometry and locates underlying application windows accordingly [case of client sided background shadows that must be ignored from window manager].

7. Estimated Time of Arrival

There is none. Latte v0.10 will be ready, when it is ready. That may take up even one more year. I am developing Latte as my fun project and I want to keep it that way. If you think it is too far, do not hesitate, come, join and help...

8. Donations

Personally I do not think donations are necessary. Easier thing you can do is to just install from KDE Store the Latte related widgets, they work just fine even with plasma panels. KDE Store provides me some monthly beers because of this. Funny thing in that Latte Separator that I developed in a day provides me most of the beers and Latte Dock that I develop plenty of hours daily for the last three years provides me almost none.. :) I mention it as a funny fact, please do not take it differently.

In a case, if you still want to donate you can use the following:

You can find Latte at Liberapay ,    

or you can split your donation between my active projects in kde store.

Kate - User Feedback - August 2020

Sunday 2nd of August 2020 11:28:00 AM

Starting with the 20.04 release, Kate allows the user to turn on some telemetry submission. This is a purely opt-in approach. We do not submit any data if you not actively enable this feature! For details about the introduction of this feature, see this post.

After some months of having this out in the wild, I think it is time to show up with the first data we got.

Submission numbers

First, how many submission do we get?

Actually, not that many, even in July we got just ~800 data submission. As we hopefully have a lot more active users, it seems that not a large percentage of the users actually turned on user feedback submission. For the installations via the Windows Store we know we have ~20.000 active users in the lasts months per month (with some telemetry enabled), I would assume we have more on Unices.

What can already be learned from the data we got?

Kate versions in use

Most people use the the stable 20.04.x series and not some developer snapshot at the moment. And one sees that e.g. the 20.04.0 really got replaced by most users with one of the patch releases. How fast people really update from release to release needs to be seen, given the code is in since 20.04 and 20.08 is not yet out, that can’t be seen at the moment.

Qt versions in use

Next interesting data: which Qt versions are in use? Here, most people are already on Qt 5.15.

That is on one side nice, as the latest Qt version is the version I use most often for testing. On the other side, Qt 5.15.0 unfortunately has some breakage in the QJSEngine we use (actually, Qt 5.14, too), that means, if you see random crashes with backtraces into the QJSEngine parts, hope for some 5.15.x update (or backports done by your distribution). We can’t really work around that (beside if we would use a completely different engine, that would be a major effort).

Let’s see how the feedback submissions develop in the next months. Thanks already to all people already providing feedback!

Discussion

If you want to chime in on this, feel free to join the discussion at the KDE reddit.

If you want to contribute, just join us at invent.kde.org or on kwrite-devel@kde.org.

One Weird Trick to Make Your Air-Conditioner Better

Saturday 1st of August 2020 07:45:00 PM

Those of you who read my last post know that I find summers a bit… hot. Ever since my first summer in Germany I’ve considered my trusty air cooler essential for my survival. Well, this week, with temperatures soaring to 35 degrees celsius, I had to get an upgrade.

Except that I didn’t buy the Commando 8 with 12.000 BTUs of raw cooling power, but the Comfee MPPH-07CRN7, a portable air conditioner with only 7.000 BTUs (roughly 0,5 Refrigeration Tons) of raw cooling power, for the princely sum of 199 EUR from Media Markt. It was a decent deal, exept that I thought I could carry home myself, before I saw the size and weight of that thing and had to pay more for a taxi to come and pick me up and drive the both of us home.

Setting it up just enough to get it to run was not incredibly difficult. The unit comes with a small plastic pipe to drain condensate water, and a big white flexible plastic air duct that you’re supposed to use to blow the hot exhaust air straight outside your house. I put a big bowl beside the unit where the condensate could drain out to, but the exhaust hose was a bit more tricky.

The unit comes with two ways to mount the exhaust hose: a wall mount for the ducting pipe, to use which you literally drill a 15cm diameter hole through your exterior wall and connect the duct there, and a window adapter, which you can fit into the frame of a sliding window and connect the duct to that, for a less violent solution to your exhaust woes. Unfortunately, I have a casement window (ones that swing open), so neither was going to work for me.

The first couple of nights, I used the window mount panels to cover up just enough of the window so that I could jam the exhaust pipe between the panels and the window frame, closed the window shutters above it, and stuffed a bedsheet to cover up the remaining gaps. I did however, order this: a casement window sealing kit. It’s basically a sheet of polyester that attaches to the frame and casement of your window using velcro, and then has a zipper down the middle which you can open to let the exhaust pipe through. Once that arrived, I attached it to my window, and I was ready to go.

Except not quite.

Unfortunately, there’s one giant problem with this setup - it’s grossly inefficient. And I absolutely hate inefficiencies. And because I know something’s not quite right, I can’t rest until I’ve fixed it.

Without going into too much detail about how air conditioners work - there’s an excellent video on that - there’s an important detail. Air conditioners have a hot side and a cold side. In a window AC, the hot side sits outside your window, drawing in air from the outside atmosphere, running it through the radiator to draw away the heat, and then dumping that hot air into the outside atmosphere, again. In a split AC, the hot side is a separate unit that sits somewhere outside your house, and connects to a cassette or indoor circulator through sealed coolant pipes.

The cold side, importantly, simply recirculates air inside the room, passing it through the cooling fins to take away heat from the air and thus cool it down. The cold air inside the room does not leave the room.

Except in a single-duct portable air conditioner.

Now portable air conditioners necessarily have to have both the hot and cold side in the same unit, and keep them both indoors. This is fine, as long as the unit is well insulated, and you’re using outside air to cool the hot side. Unfortunately, that last bit doesn’t quite work out with a single-duct portable air conditioner.

In a single-duct portable air conditioner, there only is one single duct, and it throws the hot exhaust from the hot side outside the room. But where does the air come from, you ask? Well, it’s using the air inside the room, which it just spent so much energy cooling down. Also, because it’s throwing cold air outside the room, it creates negative pressure inside the room, and this vaccuum gets replaced by warm air rushing into the room from every single crack and crevice that allows air to get into the room.

It’s so catastrophic, single-duct portable air conditioners should just be illegal, especially when the solution is so damn simple: dual ducts.

So I set about converting this unit into a dual-duct unit - one duct to take in fresh outside air, run it through the hot side of the unit, and then the second duct to throw the hot exhaust out.

And this Comfee unit makes it really easy. The hot side has only one air intake, a 26cm square grille right at the bottom of the unit. So I bought another ducting pipe from Amazon, fashioned an airbox out of some cardboard and, well, duct tape, and insulated the inside with some cotton wool padding covered with aluminium foil:

Then I used more duct tape, along with some foam padding that came with the unit to tape the airbox to the hot side intake grille, and ran the pipe to the outside using the same window:

As you know, hot air rises, so I’ve kept the intake pipe on the bottom, pointing slightly downwards. Also the intake pipe is just plastic and not insulated, so it really won’t be nice if it manages to take back any of the hot air that’s going out. The exhaust pipe, the one that I bought additionally isn’t exactly insulated, but it is double layer, with a reflective aluminium inner layer covered by a PVC outer layer, so it shouldn’t get too hot and radiate the heat back into the room.

And that’s it. Now I can stay cool, knowing that I’m not damaging the environment nearly as much as I would have been if I didn’t make the dual-duct conversion.

Until next time!

June/July in KDE Itinerary

Saturday 1st of August 2020 07:00:00 AM

The last bi-monthly report about the development of KDE Itinerary ended with a teaser for indoor map support for train stations and airports. This also dominated the work in the past weeks, and has made considerable progress so that the first features based on that have been integrated.

New Features

For every train station or airport in the itinerary timeline, it’s now possible to open the integrated indoor map view. While that already brings quite some value for locations with decent data quality (which seem to be mostly larger train stations at this point), things get a lot more interesting when looking at deeper integration and leveraging OSM data beyond just showing a map. In a few places one can already get a glimpse of what might be possible.

For finding a gate or platform, we currently only have a list for manual selection, but that’s obviously the first step towards automatically selecting the right place based on your reservations. What’s also visible is that this is already making use of data about public transport lines provided by KPublicTransport.

Train station platform finding, showing departing lines.

When picking an element on the map, we can show a number of additional information available, such as opening hours, accessibility information, payment methods or available dietary options for restaurants. While this is also mostly still just forwarding OSM data, it’s easy to imagine to eventually have filters or search options for all this.

Information box for a map element.

Indoor maps isn’t the only new feature in the app though, we can now also show vehicle load information for public transport operators providing that information. That’s useful when looking for an alternative connection, and specifically nowadays when a very crowded train can be a bigger issue than just being a minor discomfort.

Colored seat icon indicating the expected vehicle load. Infrastructure Work

There’s also a lot of work needed behind the scenes to support the indoor map support, in particular regarding providing up-to-date OSM data for it. See the recent posts on the necessary data and updating maps.kde.org for this.

Another also data-related change is the new support for Benerail station identifiers. This consists of a new property for Wikidata, the inclusion of that in KItinerary’s lookup tables, and the use of that for resolving station references in e.g. Thalys barcodes.

Fixes & Improvements

There’s a few more noteworthy changes in other areas too:

  • Besides boarding passes and event tickets, so-called “generic” Apple Wallet passes are now displayed correctly by the KMail Apple Wallet pass plug-in.
  • We fixed an ambiguity in the vicinity of China in the coordinate-based timezone lookup system which was caused by openSUSE patching the IANA timezone database with an additional Asia/Beijing alias, and our data tables being generated on such a system.
  • Seat reservation information from Ouigo confirmation emails are now extracted correctly.
Contribute

While field testing and collecting training samples of travel documents is currently not that easy, there’s plenty of other things that can be done. The KDE Itinerary workboard or the more specialized indoor map workboard show what’s on the todo list, and are a good place for collecting new ideas. For questions and suggestions, please feel free to join us on the KDE PIM mailing list or in the #kontact channel on Matrix or Freenode.

More in Tux Machines

New Prototype Builds Bringing Leap, SLE Closer Will be Available Soon

The release manager for openSUSE Leap, Lubos Kocman, has updated openSUSE’s develop community on efforts to bring the codes of Leap and SUSE Linux Enterprise closer together. In an email to the openSUSE-Factory mailing list, Kocman explained that the prototype project openSUSE Jump should become available for early testing soon and that contributions to the project could become available in the next five weeks. “First, I’d like to announce that we’ll start publishing images and FTP trees for openSUSE Jump, so people can get their hands on [it],” Kocman wrote. “Please be aware that Jump is still in Alpha quality. I expect data to be available later this week as there is still pending work on pontifex by Heroes. The Alpha quality state of Jump is gradually progressing. Jump is an interim name given to the experimental distribution in the Open Build Service as developers try to synchronize SLE binaries for openSUSE Leap. Kocman explained how feature requests will work, the process for how contributions will be handled and and he also explained how the submissions will lead to greater transparency. Read more

Linux 5.9 Performance Is Off To A Great Start With FSGSBASE Boost

FSGSBASE particularly helps out context switching heavy workloads like I/O and allowing user-space software to write to the x86_64 GSBASE without kernel interaction. That in turn has been of interest to Java and others. While going through patch review, we've benchmarked FSGSBASE patches at different points and found the performance benefits to be evident and helping in areas hurt by the likes of Spectre/Meltdown. FSGSBASE is supported on Intel CPUs since Ivy Bridge as well as newer AMD CPUs, where the performance is also helped. On Linux 5.9 where FSGSBASE is finally mainlined, it's enabled by default on supported CPUs. FSGSBASE can be disabled at kernel boot time via the "nofsgsbase" kernel option. On Linux 5.9+, looking for "fsgsbase" in the /proc/cpuinfo is the indicator whether FSGSBASE kernel usage is happening though note prior to 5.9 on supported CPUs the "fsgsbase" string is always present. For this article are some early data points of Linux 5.9 tested out-of-the-box on a Git snapshot and then again when booting that kernel image with "nofsgsbase" and repeating the tests. Via the Phoronix Test Suite various benchmarks relevant to FSGSBASE testing were carried out. Quick tests on both Intel Core and AMD Ryzen are done for this article while additional tests will be coming of Linux 5.9 over the weeks ahead -- 5.9-rc1 isn't even out until next weekend as marking the end of 5.9 features landing. Read more Also: User Xattr Support Finally Landing For NFS In Linux 5.9 Please pull NFS server updates for v5.9

Python Programming

today's leftovers

  • "Hey, DT. Why Arco Linux Instead Of Arch?" (Plus Other Questions Answered)

    In this lengthy rant video, I address a few questions that I've been receiving from viewers. I discuss fake DistroTube accounts on social media, my thoughts on PeerTube, my experience with LBRY, my thoughts on Arco vs Arch vs Artix, and what YouTubers have influenced my life.

  • 2020-08-10 | Linux Headlines 186

    elementary OS teases big changes coming in version 6, RetroArch rolls out major search improvements with version 1.9, Microsoft releases Minecraft: Education Edition for Chromebooks, and the new Krita Scripting School website aims to help developers expand the painting application.

  • R600 Gallium3D Now Has Compute Shaders Working With NIR

    If you are still rocking a pre-GCN AMD Radeon graphics card on the R600g driver for the HD 2000 through HD 6000 series, you really ought to consider upgrading in 2020, but otherwise at least from the open-source community there continues to be improvements.

  • NVIDIA GeForce are teasing something for August 31, likely RTX 3000

    Ready for your next upgrade? NVIDIA think you might be and they're teasing what is most likely the GeForce RTX 3000 launch at the end of this month. We don't know what they're actually going to call them, although they will be based on the already revealed Ampere architecture announced back in May. It's probably safe to say RTX 3000 for now, going by the last two generations being 1000 and 2000 but NVIDIA may go for something more fancy this time.

  • How to Learn Python in 21 Days?

    Before moving further, let’s have a brief introduction to Python Language. Python, designed by Guido Van Rossum in 1991, is a general-purpose programming language. The language is widely used in Web Development, Data Science, Machine Learning, and various other trending domains in the tech world. Moreover, Python supports multiple programming paradigms and has a huge set of libraries and tools. Also, the language offers various other key features such as better code readability, vast community support, fewer lines of code, and many more. Here in this article, we’ll discuss a thorough curriculum or roadmap that you need to follow to learn Python in just 21 days!

  • This Week In Servo 135

    Last week we released Firefox Reality v1.2, which includes a smoother developer tools experience, along with support for Unity WebXR content and self-signed SSL certificates. See the full release notes for more information about the new release.