Ir para o conteúdo

Sexta, 22 de Abril de 2022

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


O que você pode fazer com ele

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ém1.


Contribuições são Bem-Vindas

Se você está interessado em me ajudar com meus projetos, eu iria adorar qualquer ajuda, seja ela com códigos, ou reportando bugs.

Obrigado por ler! :)


  1. Tasks ainda não foi lançado. Você pode fazer um flatpak se quiser, só seguir essas instruções. :) ↩︎

Quarta, 13 de Abril de 2022

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.


Como ele é

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 :)


Contribuições são Bem-Vindas

Se você está interessado em me ajudar com meus projetos, eu iria adorar qualquer ajuda, seja ela com códigos, ou reportando bugs.

Obrigado por ler! :)

Terça, 22 de Março de 2022

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

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:

coast application showing the Tokyo map


Contribuições são Bem-Vindas

Se você está interessado em me ajudar com meus projetos, eu iria adorar qualquer ajuda, seja ela com códigos, ou reportando bugs.

Obrigado por ler! :)

Domingo, 6 de Março de 2022

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: githuby app

Isso é tudo por enquanto! :)

Terça, 18 de Maio de 2021

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.

Sábado, 5 de Setembro de 2020

[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.

Sexta, 4 de Setembro de 2020

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

Multithreading, vieses e bastante QML

O Akademy teve seu início hoje com sessões de treinamento

De manhã, Nuno Pinheiro do KDAB apresentou lições de Design de UI/UX usando QML para aplicações de desktop. O workshop incluiu exercícios práticos de boas práticas e de integração, assim como dicas sobre design de UI inovador. A sessão começou com os atendentes mencionando ao Nuno em que projetos eles estavam trabalhando e como eles achavam que a lição os ajudaria.

https://dot.kde.org/sites/dot.kde.org/files/photo_2020-09-04_11-29-33.jpg

Nuno comparando o QML a um filme do Sergio Leone.

Enquanto isso, na sala 2, Milian Wolff, outro engenheiro sênior de software do KDAB ensinou sobre Depuração e Profiling no Linux. Este treinamento tinha um nível um tanto mais avançado e requeriu algum conhecimento e experiência com Qt e C++, assim como entendimento básico de programação com múltiplos threads. A sessão tratou das ferramentas de depuração e profiling mais comuns no Linux e os atendentes aprenderam a usá-las assim como interpretar os resultados.

https://dot.kde.org/sites/dot.kde.org/files/Trainingsday1.png

Milian demonstrando técnicas de profiling.

Na sala 3, Michael Friedrich, defensor notório de desenvolvimento usando o GitLab, nos ensina Acelerando seu fluxo de desenvolvimento com o GitLab com seu workshop de melhores práticas. Michael nos ensina os primeiros passos para lidar com gerenciamento de projetos no Gitlab (issues, boards, labels, templates, etc.) atrelado a fluxos de desenvolvimento. Aprendemos como criar nosso primeiro merge request (MR) para solucionar um issue e fomos guiados a respeito do uso de branches, revisão de código, processos de aprovação, além de feedback de testes de CI automatizados em MRs.

https://dot.kde.org/sites/dot.kde.org/files/EhD3pbaUMAErkLv.jpg

Michael mostrando como o GitLab pode acelerar seu fluxo de desenvolvimento.

No período da tarde, Albert Astals Cid apresentou o Introdução ao QML na sala 1. O Albert ensinou como criar interfaces de usuário fluidas usando a linguagem QML e também tivemos a chance de aprender como aplicar rotinas do QML para integração com a lógica do C++.

https://dot.kde.org/sites/dot.kde.org/files/QML_Albert.png

Albert dando uma aula de mestre sobre desenvolvimento de apps com QML.

Na sala 2, David Faure falou sobre Multithreading com Qt, essencial para desenvolvedores que queiram criar aplicativos rápidos e responsivos para computadores, celulares e dispositivos embarcados utilizando-se de um número crescente de núcleos de processamento.

https://dot.kde.org/sites/dot.kde.org/files/MultithreadingQt.png

David tratando da questão delicada que é lidar com multithreading no Qt.

Por fim, para dar uma boa variada no conteúdo, a Dra. Carlee Hawkins tratou sobre Viés implícito na sala 3. Nesta sessão, fomos ensinados a levar em conta os nossos próprios vieses a respeito de raça, gênero, idade, entre outros. O modo que pesquisadores entendem por viés é explorado detalhadamente e aprendemos a como mitigar a influência dos nossos vieses nos nossos próprios pensamentos.

https://dot.kde.org/sites/dot.kde.org/files/Bias.png

Carlee ajudando a identificar e compensar pelos nossos vieses implícitos.

Os conselhos fornecidos pela Dra. Hawkins ajudará a comunidade KDE a se tornar mais receptiva e diversa para todos.

Sábado, 29 de Agosto de 2020

(Ok a piada com seqtembro funciona melhor na versão em inglês, seqtember, mas simbora)

Por uma grande coincidência, obra do destino, ou nada disso, teremos um Setembro de 2020 repleto de eventos virtuais e gratuitos de alta qualidade sobre Qt e KDE.

Começando de 4 à 11 do referido mês teremos o Akademy 2020, o grande encontro mundial da comunidade KDE que esse ano, por motivos que todos sabemos, acontecerá de forma virtual. A programação do Akademy traz palestras, treinamentos, hacking sessions, discussões com foco em aplicações KDE específicas, e mais, reunindo hackers, designers, gerentes de projetos, tradutores, e colabores dos mais diversos segmentos para discutir e planejar o KDE e seus futuros passos.

E como falamos em KDE, por extensão, também falamos em Qt – afinal, grande parte das aplicações é escrita nesse framework. Portanto, mesmo que você trabalhe com Qt mas não use nada do KDE, vale a pena participar do evento – e também se perguntar “porque diabos não estou usando e desenvolvendo aplicações do KDE?”.

Um incentivo extra é que durante o Akademy, entre 7 e 11, acontecerá o Qt Desktop Days, evento da KDAB voltado para Qt no desktop (surpresa?). A programação preliminar já está disponível e será muito interessante ver os avanços da tecnologia em um campo que pode parecer menos sexy hoje em dia, por conta da muita atenção dada a projetos mobile ou embarcados, mas que pelo contrário, continua vibrante e recebendo muito investimento.

Após uma rápida pausa para um respiro, temos a Maratona Qt. Nosso amigo Sandro Andrade, professor do IFBA e colaborador de longa data do KDE, resolveu dedicar uma semana inteira, de 14 à 18 de setembro, para apresentar 5 tópicos sobre o Qt tratando de seus fundamentos e passos iniciais de cada um. O programa cobre QML, C++ e Qt, Qt no Android, no iOS, na web (sim!), computação gráfica e mesmo jogos! Extremamente recomendada pra todo mundo que conhece ou quer conhecer o framework.

A Maratona Qt vai servir como um esquenta para a QtCon Brasil 2020, esse ano também virtual. Em 26 e 27 de setembro o pessoal da qmob.solutions reunirá desenvolvedores Qt de vários países para apresentarem, entre outras coisas, trabalhos com Wayland, visão computacional e IA, análise de dados, Python, containers, prototipagem, embarcados, e outros, tudo envolvendo Qt! E também haverá uma apresentação sobre a próxima versão major da ferramenta, Qt 6.

Portanto pessoal, reservem este mês para uma grande imersão nos vários aspectos e possibilidades disponibilizadas pelo Qt.

Sexta, 10 de Julho de 2020

Nesse sábado dia 11/07 às 10h o KDE Brasil vai voltar com episódios do Engrenagem, o videocast da comunidade brasileira (que está há 4 anos sem episódios inéditos 🙂 ).

Para retomar os trabalhos, o episódio trará 6 colaboradores brasileiros (Ângela, Aracele, Caio, Filipe (eu), Fred e Tomaz) falando de suas aplicações KDE favoritas – respectivamente, Krita, Okular, KDE Connect, Kate, Dolphin e Konsole!

Teremos comentários, apresentações de funcionalidades, e detalhes das aplicações nem sempre conhecidos por todos.

Apareçam na página do vídeo do KDE Brasil no YouTube na data e horário marcados e fique ligado para os episódios futuros!

Terça, 5 de Maio de 2020

LaKademy 2019 🔗

Filipe Saraiva filipesaraiva 18:29 +00:00
RSS

Em novembro passado, colaboradores latinoamericanos do KDE desembarcaram em Salvador/Brasil para participarem de mais uma edição do LaKademy – o Latin American Akademy. Aquela foi a sétima edição do evento (ou oitava, se você contar o Akademy-BR como o primeiro LaKademy) e a segunda com Salvador como a cidade que hospedou o evento. Sem problemas para mim: na verdade, adoraria me mudar e viver ao menos alguns anos em Salvador, cidade que gosto baste. 🙂

Foto em grupo do LaKademy 2019

Minhas principais tarefas durante o evento foram em 2 projetos: Cantor e Sprat, um “editor de rascunhos de artigos acadêmicos”. Além deles, ajudei também com tarefas de promoção como o site do LaKademy.

Nos trabalhos sobre o Cantor me foquei naqueles relacionados com organização. Por exemplo, pedi aos sysadmins que migrassem o repositório para o Gitlab do KDE e crei um site específico para o Cantor em cantor.kde.org usando o novo template em Jekyll para projetos do KDE.

O novo site é uma boa adição ao Cantor porque nós queremos comunicar melhor e mais diretamente com nossa comunidade de usuários. O site tem um blog próprio e uma seção de changelog para tornar mais fácil à comunidde seguir as notícias e principais mudanças no software.

A migração para o Gitlab nos permite utilizar o Gitlab CI como uma alternativa para integração contínua no Cantor. Eu orientei o trabalho do Rafael Gomes (que ainda não teve merge) para termos isso disponível pro projeto.

Além dos trabalhos no Cantor, desenvolvi algumas atividades relacionadas ao Sprat, um editor de rascunhos de artigos científicos em inglês. Este softwar usa katepart para implementar e metodologia de escrita de artigos científicos em inglês conhecida como PROMETHEUS, conforme descrita neste livro, como uma tentativa de auxiliar estudantes e pesquisadores em geral na tarefa de escrever artigos científicos. Durante o LaKademy finalizei o port para Qt5 e, tomara, espero lançar o projeto este ano.

Nas atividades mais sociais, participei da famosíssima reunião de promo, que discute as ações futuras do KDE para a América Latina. Nossa principal decisão foi organizar e participar mais de  eventos pequenos e distribuídos em várias cidades, marcando a presença do KDE em eventos consolidados como o FLISoL e o Software Freedom Day, e mais – mas agora, em tempos de COVID-19, isso não é mais viável. Outra decisão foi mover a organização do KDE Brasil do Phabricator para o Gitlab.

Contribuidores do KDE trabalhando pesado

Para além da parte técnica, este LaKademy foi uma oportunidade para encontrar velhos e novos amigos, beber algumas cervejas, saborear a maravilhosa cozinha bahiana, e se divertir entre um commit e outro. 🙂

Gostaria de agradecer ao KDE e.V. por apoiar o LaKademy, e Caio e Icaro por terem organizado essa edição do evento. Não vejo a hora de participar do próximo LaKademy e que isso seja o mais rápido possível! 😉