Eu queria algo para guardar minha lista de tarefas, então criei essa simples aplicação de lista de tarefas.

Com Tasks, você pode criar tarefas escrevendo o nome da nova tarefa no campo de texto no final da janela, e quando você deixa seu mouse sobre alguma tarefa ele mostra um botão de editar e de excluir.

Em cima da lista de tarefas tem um contador de tarefas na esquerda, que mostra o número total de tarefas, e um botão de limpar e de sobre, que remove todas as tarefas e mostra uma página de sobre, respectivamente.

Eu não quero que ele seja muito complexo, então não terá suporte para sub-tarefas, pelo menos por enquanto.

Eu consegui substituir meu uso de notas no desktop completamente com ele, e espero que consiga achar algum uso para ele também¹.

Welcome to KDE Gear ⚙️ 22.04!

Skip to What’s New

KDE Gear ⚙️ 22.04 brings you all the updates added to a long list of KDE apps over the last four months. KDE programs allow you to work, create and play without having to submit yourself to extortionate licenses and intrusive advertising, or surrender your privacy to unscrupulous corporations.

Below you will discover a selection of the changes added in the last four months to software designed to make your life better. But remember, there is much, much more: games, social media apps, utilities for communicating, developing and creating stuff… All these things have been worked on to give you more stability and boost your productivity.

If you want to see a full list of everything we have done, check out the complete changelog.

WARNING: There’s a lot!

Skip to What’s New

What is KDE Gear

KDE Gear is a set of apps and other software created and maintained by the KDE Community that release all new versions at the same time. KDE Gear may also include new apps that we deem have reached enough maturity to be included in the release.

When we announce a new version of KDE Gear (like we are doing today), you can expect the new versions to appear in your Linux distros shortly afterwards. In some distributions, new versions will appear nearly immediately – such as in the case of Neon. In others, it may take days or even weeks, as it depends on your distro’s packagers.

New versions of KDE Gear apps also pop up in independent app stores, such as FlatHub or the Snap Store; and as updates on non-Linux platforms, such as on Windows.

What’s New

Dolphin

Dolphin users will find that KDE’s powerful file manager now shows previews for more types of files and more information about each item in your file system in a more readable way. This makes it easier to determine accurately what is each thing and helps you decide what to open, move, copy, compress or erase before you even do it.

Dolphin can display thumbnails for ePub files, the dimensions of images under their previews, and give the extension .part for files that have only been partially downloaded or copied. When compressing single or several files, or whole directories, Dolphin now gives you a more meaningful file name, and also includes improvements for languages that are written from right to left.

Connectivity with MTP devices, such as cameras, now works much better overall and new users unfamiliar with Dolphin can find it when looking for applications just by searching for “Explorer”, “Finder”, “files”, “file manager” or “network share”.

Konsole

Another application that makes itself easy to find is Konsole, KDE’s powerful terminal emulator. Now, if you search for “cmd” or “command prompt”, Konsole will pop up as an option.

Of course, that is not the only news regarding Konsole. Konsole’s SSH plugin has been further enhanced and you can assign different visual profiles (with different colors for backgrounds, text, etc.) to each SSH account. Like that you always have a visual cue for where you are. And a completely new feature is Quick Commands: open a quick commands pane from Plugins > Show Quick Commands and you will be able to create short scripts you use frequently and invoke them when you need them with a couple of clicks.

Other new things are that Konsole now supports Sixel images that can be displayed right inside the window, and you can now open the current directory or any other folder you right-click on in any app, not just the file manager.

As for increasing usability, Konsole’s scrolling performance is now twice as fast and has been adapted for touch-scrolling.

Kdenlive

The biggest news coming out of the Kdenlive project is that now macOS users can edit videos with Kdenlive on the newer M1 devices. This opens up a whole new audience of Mac users and can help make Kdenlive a serious contender in the video-editing world.

In other news, the render dialog has been revamped and it is easier to see all the available rendering options, while at the same time adding features. Two new options in particular stick out: you can create customised profiles so that your rendered movie adapts perfectly to your needs, and you can also render by zones, using the guides you set up on the timeline as references.

There is also initial support for 10-bit color, although this is still a work in progress, as applying any effect to a 10-bit clip will drop your video down to 8-bit color. You can look forward to full 10-bit color support in future versions of Kdenlive.

Kate

Kate is much more than a text editor. It incorporates features that make it ideal for editing HTML, LaTeX and Markdown documents and provides utilities to make it an excellent programming and development environment, including comprehensive support for Git, syntax coloring, and “snippets” — templates of commonly used code.

In today’s release, you will find Kate starts up faster and makes it easier to browse your project directories and find files. It also helps you differentiate files with the same names, but placed in different locations. Along with a menu reshuffle, enhancements to the indented layout of code, and improvements to Kate’s support on Wayland, Kate improves its overall usability, stability and range of features.

Okular

Okular is KDE’s all-terrain document viewer. Apart from becoming the world’s first computer program to be awarded an eco-certification backed by a government, Okular has improved its usability and user-friendliness and now presents a welcome screen when opened without a document and alerts you immediately when you go to sign a document but have no valid digital certificates.

And also this…

• Elisa, KDE’s elegant and modern music player, improves its support for touch screens, is faster, more stable and you can now drag and drop music and playlist files from your file manager onto the playlist panel.
• With Skanpage, KDE’s scanning utility, you can now share scanned documents (including multi-page PDFs) using KDE’s general sharing system, which allows you to push documents to instant messaging apps, online cloud services, social services, and through Bluetooth to other devices.
• Spectacle’s annotation tools add functionality to crop, scale, undo, redo, and in general do many more things with the images you screenshot. Also, any annotation settings you change will be remembered the next time you startup the program.
• Gwenview, KDE’s image viewer, detects and guides you through the installation of camera importers that are lacking support packages. There is also a new Print Preview functionality for when you need a hard copy.
• KDE Itinerary, KDE’s travel assistant (also available for your phone), improves support for more train companies (such as Renfe and Amtrak) and airlines. It also adds more detailed information for weather and an inbuilt barcode scanner so you can scan your ticket’s information directly from the app.
• … And much, much more

New Arrivals

Kalendar is a modern calendaring and task managing app with an attractive interface and lots of useful features you can use to sync with all your other calendars. It works on your desktop and on Plasma Mobile.

Full changelog here.

O KDE Gira à Volta das Aplicações

One of the Goals of KDE is to be All About the Apps. This means the KDE Community takes more charge of releasing our own software and delivering it directly to you. Although we fully support distributions that ship our software, KDE Gear 22.04 apps will also be available on these Linux app stores shortly:

Se quiser ajudar a ter mais aplicações do KDE nas lojas de aplicações, ter suporte para mais lojas e ter as aplicações melhor integradas com o nosso processo de desenvolvimento, venha dizer ‘olá’ na nossa sala de conversa ‘All About the Apps’.

Um dia depois de usar alguns apps do KDE eu percebi que as telas de carregamento não eram consistentes, cada aplicativo estava implementando uma solução unica então eu criei esse LoadingPlaceholder componente pro Kirigami.

Ele lida com os seguintes estados:

• indeterminado, quando ele não sabe quando ele vai realmente carregar (primeira parte do vídeo)
• determinado, quando ele sabe quanto ele está realmente carregando (segunda parte do vídeo)

Como isso ajuda

Esse componente vai substituir as várias implementações achadas nos aplicativos, consequentemente melhorando nossa consistência!

Só queria compartilhar esse pequeno componente, com menos de 70 linhas de código já é possível melhorar muito nossa plataforma, cada pequena contribuição importa :)

Então, ontem eu estava olhando o site OpenStreetMap.org porque eu meio que gosto de mapas e decidi construir uma POC!

Eu te apresento Coast

Você pode estar se perguntando “por que ele se chama coast?”, o fundador do OpenStreetMap se chama Steve Coast e eu achei esse um bom nome para um aplicativo de mapas.

No momento ele só consegue fazer duas coisas:

• Procurar
• Mover com o mouse

Mas pelo menos ele é bonito:

E eu também fiz uma logo pra ele porque não, né?

Aqui está o código fonte se você está interessado nisso, só queria compartilhar minha animação com esse simples mapa! :)

Nessa ultimas duas semanas eu estava aprendendo como buscar APIs com Qt and eu finalmente consegui fazer alguma coisa funcional! Nesse post a gente vai criar uma pequena aplicação que busca informação sobre um usuário especifico do github.

Primeiras etapas

Eu vou estar usando esse tutorial Kirigami como um ponto de partida.

Primeiro a gente vai criar dois arquivos src/controller.h e src/controller.cpp e adicionar src/controller.cpp no arquivo src/CMakeLists.txt:

src/CMakeLists.txt

add_executable(... controller.cpp ...)

src/controller.h

#include <QObject>
#include <QNetworkAccessManager>

class Controller : public QObject
{
    Q_OBJECT

public:
    Q_INVOKABLE void fetch(QString username);

private:
    QNetworkAccessManager m_manager;
};

No arquivo de cabeçalho temos essa classe Controller que herda do QObject, ela tem um QNetworkAccessManager como membro que nós vamos utilizar para fazer requisições e uma função fetch que recebe um usuário do github como parametro. A macro Q_INVOKABLE é usado para que possamos chamar essa função pelo QML.

src/controller.cpp

#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>
#include <QDebug>

#include "controller.h"

void Controller::fetch(QString username)
{
    if (username.isEmpty()) {
        qWarning() << "Username must not be empty";
        return;
    }

    QNetworkRequest request = QNetworkRequest(QString("https://api.github.com/users/%1").arg(username));
    QNetworkReply* reply = m_manager.get(request);

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            qDebug() << object;
        }
        reply->deleteLater(); // make sure to clean up
    });
}

No arquivo .cpp primeiro verificamos se username está vazio, se sim mostramos um aviso e retornamos.

Depois nós criamos a request passando a URL da API do github como argumento pro QNetworkRequest e usamos uma QString para guardar o username.

Então a gente cria uma reply usando um metodo de um membro da nossa classe que a gente declarou antes, o metodo get(), que recebe a request que a gente acabou de criar como argumento e retorna uma QNetworkReply.

Então nós conectamos á um sinal do QNetworkReply que diz pra gente que está tudo pronto, verificamos se não tem um erro, se tiver mostramos um aviso e a mensagem de erro, se não tem nenhum erro nós continuamos.

Vamos guardar tudo que veio da requisição em replyData como uma QString e então transformar tudo em um QJsonDocument e guardar isso em document. O primeiro elemento da API do github é um objeto então a gente pode acessar esse objeto com document.object();

Se a gente printar isso vamos ter uma coisa tipo essa:

QJsonObject(
    {
        "avatar_url":"https://avatars.githubusercontent.com/u/52990296?v=4",
        "bio":"My KDE's gitlab profile is way more interesting",
        "blog":"fhek.gitlab.io",
        "company":"@KDE",
        "created_at":"2019-07-17T05:13:51Z",
        "email":null,
        "events_url":"https://api.github.com/users/FHEK789/events{/privacy}",
        "followers":13,
        "followers_url":"https://api.github.com/users/FHEK789/followers",
        "following":4,
        "following_url":"https://api.github.com/users/FHEK789/following{/other_user}",
        "gists_url":"https://api.github.com/users/FHEK789/gists{/gist_id}",
        "gravatar_id":"",
        "hireable":true,
        "html_url":"https://github.com/FHEK789",
        "id":52990296,
        "location":"Brazil",
        "login":"FHEK789",
        "name":"Felipe Kinoshita",
        "node_id":"MDQ6VXNlcjUyOTkwMjk2",
        "organizations_url":"https://api.github.com/users/FHEK789/orgs",
        "public_gists":0,
        "public_repos":3,
        "received_events_url":"https://api.github.com/users/FHEK789/received_events",
        "repos_url":"https://api.github.com/users/FHEK789/repos",
        "site_admin":false,
        "starred_url":"https://api.github.com/users/FHEK789/starred{/owner}{/repo}",
        "subscriptions_url":"https://api.github.com/users/FHEK789/subscriptions",
        "twitter_username":null,
        "type":"User",
        "updated_at":"2021-12-17T17:47:02Z",
        "url":"https://api.github.com/users/FHEK789"
    }
)

Eba! Nossa primeira requisação usando Qt!

Criando algumas propriedades

Agora vamos criar algumas propriedades para guardar os valores que a gente quer do documento JSON, por enquanto vamos só guardar o nome do usuário:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)

    ...

Q_SIGNALS:
    void nameChanged();

private:
    QNetworkAccessManager m_manager;

    QString m_name;
};

A gente usa essa macro Q_PROPERTY pra criar propriedades, que funcionam como membros mas com algumas funções adicionais, você pode ler mais sobre isso aqui, então a gente faz nosso sinal e membro guardar o nome do usuário.

src/controller.cpp

void Controller::fetch(QString username)
{
    ...

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            // ask object for value
            QJsonValue name = object.value(QString("name"));
            m_name = name.toString();
            Q_EMIT nameChanged();
        }
        reply->deleteLater(); // make sure to clean up
    });
}

Agora invés de pegar todos os dados, vamos pedir apenas pelo nome do usuário. Nós podemos acessar esse valor usando essa notação .value(), e então definir m_name como uma versão string do valor em JSON e emitor o sinal nameChanged para que nossa aplicação saiba que nossa propriedade mudou.

Vamos repetir esse processo pra guardar todos os dados que a gente quer, que vai se parecer com alguma coisa tipo essa:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString login READ login NOTIFY loginChanged)
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
    Q_PROPERTY(QString bio READ bio NOTIFY bioChanged)
    Q_PROPERTY(QString avatarURL READ avatarURL NOTIFY avatarURLChanged)
    Q_PROPERTY(QUrl profileURL READ profileURL NOTIFY profileURLChanged)

    ...

Q_SIGNALS:
    void loginChanged();
    void nameChanged();
    void bioChanged();
    void avatarURLChanged();
    void profileURLChanged();

private:
    QNetworkAccessManager m_manager;

    QString m_login;
    QString m_name;
    QString m_bio;
    QString m_avatarURL;
    QUrl m_profileURL;
};

src/controller.cpp

...

void Controller::fetch(QString username)
{
    ...

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            // ask object for value
            QJsonValue login = object.value(QString("login"));
            m_login = login.toString();
            Q_EMIT loginChanged();

            QJsonValue name = object.value(QString("name"));
            m_name = name.toString();
            Q_EMIT nameChanged();

            QJsonValue bio = object.value(QString("bio"));
            m_bio = bio.toString();
            Q_EMIT bioChanged();

            QJsonValue avatarURL = object.value(QString("avatar_url"));
            m_avatarURL = avatarURL.toString();
            Q_EMIT avatarURLChanged();

            QJsonValue profileURL = object.value(QString("html_url"));
            m_profileURL = profileURL.toString();
            Q_EMIT profileURLChanged();
        }
        reply->deleteLater(); // make sure to clean up
    });
}

Declaramos alguns metodos que vão retornar essas propriedades:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString login READ login NOTIFY loginChanged)
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
    Q_PROPERTY(QString bio READ bio NOTIFY bioChanged)
    Q_PROPERTY(QString avatarURL READ avatarURL NOTIFY avatarURLChanged)
    Q_PROPERTY(QUrl profileURL READ profileURL NOTIFY profileURLChanged)

public:
    Q_INVOKABLE void fetch(QString username);

    QString login();
    QString name();
    QString bio();
    QString avatarURL();
    QUrl profileURL();

    ...
};

E definir eles no arquivo .cpp:

src/controller.cpp

...

QString Controller::login()
{
    return m_login;
}

QString Controller::name()
{
    return m_name;
}

QString Controller::bio()
{
    return m_bio;
}

QString Controller::avatarURL()
{
    return m_avatarURL;
}

QUrl Controller::profileURL()
{
    return m_profileURL;
}

Deixando nossa classe disponivel em QML

Finalmente deixamos essa classe disponivel pra nossa aplicação:

src/main.cpp

...

#include "controller.h"

int main(int argc, char *argv[])
{
    ...

    QQmlApplicationEngine engine;

    qmlRegisterSingletonInstance("org.kde.githuby", 1, 0, "Controller", new Controller);

    ...
}

qmlRegisterSingletonInstance é usado para fazer nossa classe disponivel em QML, agora a gente pode chamar ela nos nossos arquivos QML assim:

src/contents/main.qml

import QtQuick 2.15
import QtQuick.Controls 2.15 as QQC2
import QtQuick.Layouts 1.15
import org.kde.kirigami 2.19 as Kirigami

import org.kde.githuby 1.0

...

Você pode mostrar essas informação de qualquer jeito que quiser, aqui está como eu fiz:

/*
    SPDX-License-Identifier: GPL-2.0-or-later
    SPDX-FileCopyrightText: 2022 Felipe Kinoshita <kinofhek@gmail.com>
*/

import QtQuick 2.15
import QtQuick.Controls 2.15 as QQC2
import QtQuick.Layouts 1.15
import org.kde.kirigami 2.19 as Kirigami
import QtGraphicalEffects 1.15

import org.kde.githuby 1.0

Kirigami.ApplicationWindow {
    id: root

    title: i18n("githuby")

    minimumWidth: Kirigami.Units.gridUnit * 20
    minimumHeight: Kirigami.Units.gridUnit * 20
    width: Kirigami.Units.gridUnit * 25
    height: Kirigami.Units.gridUnit * 25

    header: QQC2.ToolBar {
        RowLayout {
            anchors.fill: parent

            Kirigami.SearchField {
                id: searchField
                Layout.fillWidth: true

                placeholderText: i18n("Insert github username")
                autoAccept: false
                onAccepted: Controller.fetch(text)
            }
        }
    }

    pageStack.initialPage: Kirigami.Page {
        id: page

        globalToolBarStyle: Kirigami.ApplicationHeaderStyle.None

        Kirigami.PlaceholderMessage {
            id: placeholder

            anchors.centerIn: parent
        }

        ColumnLayout {
            id: content
            visible: false

            width: parent.width - (Kirigami.Units.largeSpacing * 4)
            anchors.centerIn: parent

            Image {
                id: img

                Layout.alignment: Qt.AlignHCenter
                sourceSize.height: Kirigami.Units.gridUnit * 10
                fillMode: Image.PreserveAspectFit
                source: Controller.avatarURL

                layer.enabled: true
                layer.effect: OpacityMask {
                    maskSource: Item {
                        width: img.width
                        height: img.height
                        Rectangle {
                            anchors.centerIn: parent
                            width: img.width
                            height: img.height
                            radius: Kirigami.Units.smallSpacing
                        }
                    }
                }
            }
            Kirigami.Heading {
                Layout.alignment: Qt.AlignHCenter
                text: Controller.name
                type: Kirigami.Heading.Primary
                font.underline: mousearea.containsMouse

                MouseArea {
                    id: mousearea
                    anchors.fill: parent

                    cursorShape: Qt.PointingHandCursor
                    hoverEnabled: true

                    onClicked: Qt.openUrlExternally(Controller.profileURL)
                }
            }
            Kirigami.Heading {
                Layout.alignment: Qt.AlignHCenter
                text: Controller.login
            }
            QQC2.Label {
                Layout.fillWidth: true
                Layout.alignment: Qt.AlignHCenter
                horizontalAlignment: Qt.AlignHCenter
                text: Controller.bio
                wrapMode: Text.Wrap
            }
        }
    }
}

Como que ficou

E é assim que ela se parece:

Isso é tudo por enquanto! :)

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations.

Os criadores de pacotes das distribuições e lojas de aplicações deverão actualizar os seus pacotes de aplicações.

• 21.12 release notes for information on tarballs and known issues.
• Página da transferência de pacotes na wiki
• 21.12.2 source info page
• 21.12.2 full changelog

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations.

Os criadores de pacotes das distribuições e lojas de aplicações deverão actualizar os seus pacotes de aplicações.

• 21.12 release notes for information on tarballs and known issues.
• Página da transferência de pacotes na wiki
• 21.12.1 source info page
• 21.12.1 full changelog

O beta do Plasma 5.22, de versão 5.21.90, foi lançado no dia 13 de maio de 2021. Ele serve para que, num espaço de mais ou menos três semanas, mais usuários possam testar e relatar erros e regressões no sistema, para garantir um futuro lançamento mais estável para todos.

Uma semana após o lançamento do beta, no sábado, 22 de maio de 2021, teremos o Plasma Beta Review Day, o dia de caça aos bugs, começando às 5h e terminando às 10h da manhã, no fuso GMT-3 Brasília (ou das 10h às 15h horas, no fuso CEST).

Convidamos você a participar e se unir a vários outros usuários de todas as partes do mundo, para contribuir com testes e triagem de bugs, num processo estruturado em que você aprende fazendo.

Para essa reunião ao vivo e completamente online, usaremos uma sala de videoconferência da instância do BigBlueButton da KDE, o link para acesso é: https://meet.kde.org/b/dav-gmr-qzx . Você pode se unir às conversas com microfone e câmera, assistir e interagir no chat, ou apenas ficar acompanhando o movimento.

Para participar não é estritamente necessário instalar o sistema com o beta em sua máquina; você pode usar um LiveUSB com uma imagem do KDE Neon Testing/Unstable ou do openSUSE Krypton e testar, sem perigo para sua máquina, ou você pode usar uma máquina virtual. Outras distribuições têm seus próprios meios de testar o beta também. Para tirar dúvidas e conversar, é necessário saber um básico de inglês. Caso não saiba nada de inglês, podemos ajudar com seus testes e triagem no grupo do Telegram do KDE Brasil que está conectado ao IRC do #kde-brasil, não se preocupe.

No dia de caça aos bugs, você vai ver aprender a lidar com o Bugzilla e responderemos as suas perguntas sobre como reportar erros e fazer triagem, assim como adquirir prática validando relatórios e identificando duplicatas, testando o que há de novo no Plasma e, talvez, até tenhamos desenvolvedores consertando bugs que você mesmo esteja experienciando. Ao nos ajudar com a caça aos bugs você não somente estará nos ajudando a deixar o novo lançamento mais estável como também contribuindo para que os desenvolvedores tenham mais tempo para lidar com desenvolvimento, ao invés de lidar com relatórios inválidos, difíceis de entender ou duplicatas. Portanto, não deixe de participar! Sua ajuda vale muito.

[Esta é uma tradução do artigo original postado no Dot KDE.]

Um dia cheio de palestras fascinantes

O primeiro dia de palestras do Akademy foi bem variado e interessante, cobrindo uma grande variedade de tópicos, desde o gerenciamento de projetos de metas e avanços técnicos em tecnologias Qt e KDE até um programa de odontologia de código aberto e Linux para automóveis.

Aleix Pol, presidente da KDE, deu início ao dia exatamente às 6:00 da manhã no Brasil com um vídeo feito por Bhavisha Dhruve e Skye Fentras para dar as boas vindas a todos por participarem do evento.

Após mencionar as circunstâncias bastante únicas do Akademy deste ano, Aleix introduziu a primeira palestrante, Gina Häußge.

Gina é a criadora e mantenedora do OctoPrint, um sistema cheio de funções e bem sucedido usado para controlar sua impressora 3D por meio de uma interface web. Em sua palestra, Gina tratou tanto de suas experiências boas como das ruins ao assumir o papel de mantenedora de um projeto de código aberto independente. Ela falou sobre o sentimento de liberdade e propósito adquirido ao trabalhar com o projeto, assim como dos pontos negativos de instabilidade financeira e frequentemente se sentir sozinha a despeito de estar trabalhando em algo que serviria a centenas, talvez milhares de usuários. Apesar das desvantagens, Gina admitiu alegremente que faria tudo isso novamente se tivesse a chance e que a sensação de estar ajudando outras pessoas, além da realização que experienciou, definitivamente compensam os momentos ruins.

A palestra de Gina resumida de maneira gráfica por Kevin Ottens.

Logo após foi a hora de outro contribuidor veterano de código aberto brilhar: Jonathan Riddell tratou de como liderou uma das metas atuais da comunidade KDE: Tudo sobre os apps, o projeto no qual membros da comunidade promovem e distribuem os aplicativos da KDE com liberdade, até mesmo onde não haja a área de trabalho do Plasma da KDE. Jonathan mencionou suas motivações para propor esta meta e o resultado do trabalho feito desde seu anúncio no Akademy 2019.

Jonathan Riddell falando sobre o progresso feito na meta Tudo sobre os apps.

De modo semelhante, Niccolo Venerandi apresentou sobre a meta de Consistência. Esta meta tem o objetivo de unificar a aparência do Plasma e de todos os apps da KDE de modo a fornecer uma experiência coerente para os usuários. Niccolo mencionou o fato de que o Plasma não tem problemas sérios de consistência, e sim abordagens diferentes no design de apps que pode ocasionalmente levar a uma quantidade surpreendente de visuais e comportamentos. Niccolo então nos mostra o futuro dos aplicativos da KDE e, honestamente? Parece incrível.

As apresentações tratando individualmente das metas acabaram com Méven Car falando sobre Wayland. Já não é segredo algum que o porte do software e das tecnologias da KDE para o Wayland, o substituto para o clássico sistema de janelas X, está tendo seus altos e baixos. Por isso mesmo a comunidade KDE decidiu tornar o Wayland uma prioridade. A meta do Wayland é uma tarefa difícil que exige atualizações em múltiplos componentes e fazendo como que todo o conjunto gráfico da KDE seja refeito. Como Méven explica, no entanto, a comunidade fez bastante progresso desde o Akademy 2019.

Dando continuidade à apresentação individual das metas da KDE, Niccolo Venerandi, Méven Car, Jonathan Riddell, Lydia Pintscher e Adam Szopa se reuniram para sintetizar como foi o primeiro ano e o subsequente aprendizado em lidar com as metas.

Após a reunião, Andreas Cord-Landwehr falou por dez minutos sobre o SPDX, um sistema usado para licensiamento mais eficiente. Nesta apresentação aprendemos que identificadores do SPDX são um passo importante para permitir o uso de ferramentas automáticas que verifiquem declarações de licensiamento. Andreas explicou as vantagens de usá-las e quão simples é aplicar elas. Ele também deu um resumo curto sobre o que já foi feito em relação ao KDE Frameworks e onde contribuidores podem ajudar e dar apoio à conversão para o SPDX.

Em seguida Shawn Rutledge tratou de Edição de Markdown usando QTextDocument em outra palestra de 10 minutos. Shawn adicionou suporte ao Markdown de primeira no Qt 5.14 e como alternativa ao conjunto limitado de HTML que o QTextDocument costumava usar. Durante a palestra, ele demonstrou alguns editores WYSIWYG escritos com widgets e com Qt Quick.

Como última apresentação curta antes do almoço, Carl Schwan expôs Como criar um bom site promocional para o seu projeto. Carl é o contribuidor principal por trás das melhorias drásticas em muitos dos sites da KDE, incluindo o kde.org. Durante a palestra, Carl apresentou o tema de Jekyll da KDE, a motivação por trás do projeto, e explicou brevemente como o tema pode ser usado para criar um site da KDE. Ele também apresentou exemplos de sites com design pobre e como eles podem ser melhorados para tornar os projetos mais atrativos para usuários em potencial.

Os Akadêmicos aproveitando o período de descanso entre as palestras da manhã e da noite.

No período da tarde, as apresentações tiveram início com a palestra do conselho administrativo do KDE e.V. e relatórios dos Grupos de Trabalho. O conselho falou aos atendentes sobre todas as coisas que eles fizeram ao longo do ano desde o último Akademy. Algumas ações de destaque foram o aumento do número de três empregados pagos para cinco, a migração para o GitLab e um aumento no fundo de suporte para os membros da comunidade. O conselho então prosseguiu tratando dos detalhes das atividades do vários grupos de trabalho, embora algumas de suas apresentações tenham sido relocadas para o fim do dia devido ao tempo disponível.

O texto completo do Relatório Anual da KDE – 2019 está disponível para leitura à vontade.

E então voltamos à programação de palestras com a Atualização do gerenciamento de entrada, apresentado novamente por Shawn Rutledge. Nesta palestra, Shawn falou sobre o que está por vir e as várias metas para eventos de entrada no Qt 6.

Cornelius Schumacher contando a história da KDE Free Qt Foundation.

Enquanto isso, na sala 2, Cornelius Schumacher falou sobre a KDE Free Qt Foundation. Estabelecida em 1998, a KDE Free Qt Foundation foi fundada para manter o Qt toolkit livre para a KDE e todos os outros projetos de software livre. A fundação se manteve firme durante as mais de duas décadas de períodos ocasionalmente turbulentos que o Qt e a KDE passaram juntos. Cornelius narrou a história de como isso tudo funcionava.

E falando da The Qt Company… Um pouco depois, na sala 1, Richard Moe Gustavsen falou sobre Suporte nativo a estilos para desktop com o Qt Quick Controls 2 e o trabalho contínuo da empresa para dar suporte à escrita de aplicativos de desktop usando Qt Quick Controls 2.

Ao mesmo tempo, na sala 2, Aleix Pol tratou dos Produtos da KDE e como visualizar a relação deles com os usuários. Na palestra, Aleix introduziu um sistema para ajudar desenvolvedores a garantir que a comunidade de software livre e seus usuários sejam protegidos.

Na sequência, na sala 1 Patrick Pereira apresentou Criação rápida de protótipos QML – Desenvolvendo ferramentas para melhorar o desenvolvimento e protótipos QML. Em sua palestra, Patrick falou sobre como a criação de protótipos é feita por todo desenvolvedor de QML e como fazer isso de modo eficiente. Ele utilizou dois projetos como exemplo: QHot (um programa para atualização ao vivo de arquivos QML aninhados) e QML Online (um editor QML online feito com WebAssembly) para explicar como diminuir o tempo de desenvolvimeto e a curva de aprendizado para o QML.

Jonah Thelin dentro de seu carro falando sobre linux em carros.

Na sala 2, Johan Thelin deu início à sua palestra Linux em carros – O que que há? de dentro de seu carro. Literalmente. Johan falou de como carros ainda usam tanto software proprietário ao ponto de ser difícil encontrar as partes que são efetivamente de código aberto, mesmo quando o linux é usado por trás. Ele também falou sobre que medidas são necessárias para melhorar a situação e como software da KDE pode servir para esse tipo de uso.

Logo após essa sequência de palestras de extensão normal, houve três apresentações rápidas de 10 minutos.

Com o Flatpak, Flathub e a KDE: Um resumo geral, Albert Astals Cid introduz a platéia ao Flatpak, explica o que o Flathub é e como a KDE interage com ambos.

Nicolás Alvarez então falou de Como melhorar a infraestrutura de servidores da KDE, da formação do grupo de trabalho dos sysadmins, e explicou aos atendentes como o time de sysadmin está no processo de tornar servidores da KDE melhor gerenciáveis reduzindo “dívidas técnicas”, transferindo tarefas manuais para scripts, melhorando a documentação e tornando mais coisas testáveis localmente antes de sua inserção nos servidores reais.

Na última apresentação rápida do dia, David Edmundson deu dicas de Como ganhar um argumento com um mantenedor, uma vez que testemunhou e participou de centenas de discussões no Bugzilla e no Phabricator que acabavam se tornando impasses emocionais. Ele compartilhou com a platéia os métodos que ele viu funcionar para alcançar meio-termos produtivos e alertou de certas que atitudes que podem levar situações técnicas a experiências desagradáveis para todos.

Logo após se seguiu uma das apresentações mais surpreendentes do dia apresentada por Tej Shah, doutor em Odontologia dos EUA. Tej falou sobre seu projeto Clear.Dental e sua tentativa de converter a odonto para o lado do código aberto usando o poder do Linux, do Qt e da KDE. Ele revisou o estado dos softwares usados no tratamento de dentes (lamentável, por sinal), o problema que existe com os programas atuais, e como o Clear.Dental pode contribuir para resolver tudo isso.

Ao mesmo tempo, na sala 2, Camilo Higuita tratou de seu projeto filho, o Maui, e deu à audiência um geral sobre o que há de novo no grupo de apps, serviços, bibliotecas e infraestrutura de UI que o Maui fornece para criar programas elegantes.

Na sessão seguinte, Rohan Garg deu uma lição aos atendentes com seu Introdução ao hardware gráfico no Linux explicando como a crescente popularidade dos dispositivos ARM levou à criação de arquiteturas de plataforma com hardware gráfico mais peculiar. Ele falou sobre o básico do stack gráfico do Linux funciona e a história por trás de como chegamos aos atual design do Gallium no Mesa.

Por fim, a participante do Google Summer of Code, Amy Spark, exibiu Integrando programas de código aberto de hollywood com aplicativos KDE com o porte da tecnologia de animação da Disney para o Krita. O SeExpr dá a artistas usando o Krita acesso à geração procedural de texturas, permitindo a inclusão de detalhes ínfimos de superfície, efeitos de iluminação, superposições e outros com o aperto de um botão. Como linguagem de script, ele dá aos criadores de conteúdo a flexibilidade necessária para garantir resultados perfeitos de maneira consistente alterando o algoritmo a suas necessidades. Amy teve que superar várias barreiras técnicas durante o processo de portar, uma vez que o SeExpr foi feito originalmente para rodar em um conjunto de software proprietário específico.

David Revoy mostrando um exemplo do SeExpr sendo usado em uma imagem da webcomic "Pepper and Carrot".

Caso você tenha perdido, as palestras do dia estão disponíveis online em três blocos: um da manhã e dois para cada uma das salas usadas à tarde. Nós também gravamos todas as palestras e você poderá assistir cada uma separadamente nas plataformas de vídeo da KDE disponíveis em breve.

Amanhã nós iremos fazer streaming novamente via BigBlueButton, diretamente dos nossos servidores, e pelo YouTube.