|
|
![]() |
| shadows with size:100% and opacity:100% |
![]() |
| dock/panel options |
LibAlkimia is a base library that contains support for financial applications based on the Qt C++ framework. One of its main features is the encapsulation of The GNU Multiple Precision Arithmetic Library (GMP) and so providing a simple object to be used representing monetary values in the form of rational numbers. All the mathematical details are …
Como es habitual, para el día de Reyes, dedico una entrada un poco especial, ya que se sale de la tónica habitual del blog. Se trata de hacer un recopilatorio con los mejores juegos libres GNU Linux para 2018, porque los jugones también tienen cabida en el mundo del conocimiento libre.
Jugar en GNU/Linux es cada día más fácil. Dejando de lado los juegos emulados o los de KDE Games, hoy quiero presentaros una lista de juegos libres, que hayan sido actualizados a los largo del 2017, lo cual significa que están vivos y mejorando.

Empezamos el repaso a algunos de los mejores juegos libres GNU Linux para 2018 con un FPS (First Person Shooter) cuya última actualización se realizó el noviembre de 2017. Se trata de Alien Arena: Warriors of Mars un clásico juego de disparos en primera persona frenéticos y que este 2017 ha sido especialmente bueno: ha sido lanzado en Steam y ha lanzado una gran actualización.
Un gran juego para pasar horas y horas disfrutando con amigos y amigas, ambientado en la ciencia ficción de los años 50.
Si buscas un juego de estrategia en tiempo real ambientado en un mundo fantástico MegaGlest es tu juego. Con unos gráficos asombrosos y 100% libre, esta evolución del Glest no tiene nada que envidiar a los clásicos Warcraft.
Este año ha alcazado la versión 3.13.0 con mejoras en la IA y en la costrucción multilple de estructuras.
Seguimos con Battle for Wesnoth, un gran juego de estrategia por turnos que es puro vicio y que aunque este año no ha lanzado una nueva versión, si que se ha actualizado lanzando diversas betas de la 1.14.
Este juego tiene diferentes modalidades: un solo jugador, online y silla caliente, y está ambientado en un mundo de fantasía medieval.
Así que este año 2018 podemos seguir disfrutando de Battle for Wesnoth 1.12 mientras esperamos la siguiente versión.
Ahora volvemos con un FPS, Xonotic que fue desarrollado como un fork de Nexuiz y que actualmente funciona bajo una versión my modificada del motor gráfico Quake, conocido como DarkPlaces.
Su jugabilidad está inspirada en las series Unreal Tournament y Quake, pero con elementos extra que lo diferencian y que lo hacen único y personal.
El pasado mes de abril fue lanzada la versión Xonotic 0.8.2 la cual funciona bajo Linux, Windows o Mac, ¡sin necesidad si quiera de un instalador! Simplemente descarga el zip, descomprime y ejecuta el archivo correspondiente.
También existen los simuladores de estrategia en tiempo real en Linux en esta lista de los mejores juegos libres GNU Linux para 2018. Y un buen ejemplo es 0. A.D. , donde tomamos el control de una sociedad que debe construir una base, explotar recursos, entrenar un ejército, descubrir tecnologías y combatir; dando gran importancia al desarrollo económico y militar, reviviendo batallas épicas entre civilizaciones que marcaron un antes y un después en la historia de la humanidad. Vía: Wikipedia 0. A.D.
Este año 0 A.D. ha lanzó en julio su versión Alpha 22 “Venustas que ofrece un aspecto gráfico espectacular, sonido cuidado y muchas novedades como nuevo modo de juego, nuevos modelos, texturas y animaciones, mejoras en el multijugador y nuevos mapas.
Según la Wikipedia, Freeciv es un videojuego de estrategia por turnos, inspirado en el juego Civilization. Es software libre, está licenciado bajo la GNU GPL y además de ser gratuito. En otras palabras, una verdadera joya para los amantes de este tipo de de juegos.
Este año, en agosto, se ha llegado a la versión 2.5.8, y este pasado septiembre se lanzó la beta de 2.6
Volvemos a los videojuegos de acción en primera persona basado en el motor CUBE . AssaultCube está hecho para jugar online por servidores, pero tiene un modo desconectado con el que se puede jugar con bots, emulando una partida online.
AssaultCube es gratuito, ya que su motor es Código abierto, aunque sus texturas y otras partes del juego no lo son. Vía: Wikipedia
Este año se ha iniciado la transición a SDL2, lo cual está llevando mucho trabajo pero que es irreversible.
Y seguimos con ls FPS. Es el turno de Red Eclipse, que también utiliza el motor CUBE, y que destaca por su toque de Parkour, esa disciplina que consiste en hacer saltos y volteretas mientras corres como un poseso por el campo de batalla.
La versión 1.6 “Sunset Edition” fue lanzada el pasado 21 de diciembre con algunas novedades, aunque la más destacable para mi fue la inclusión de la versión AppImage.
La diversión está garantizada con uno de los pocos juegos que tiene un hueco en el blog y que merece, por tanto, estar en la lista de los mejores juegos libres GNU Linux para 2018. Se trata de SuperTuxKart un juego libre y gratuito de carreras de karts tipo arcade en 3D, cuyo protagonista es Tux, la mascota del kernel Linux, que comparte protagonismo con otras mascotas como Konqi, Gnu, Kiki (mascota de Krita) y un largo elenco de peronajes.
SuperTux lanzó su última versión (la 0.9.3) este pasado noviembre con novedades como la inclusión de Kiki, nuevos efectos en los karts, 3 nuevos circuitos y, la más importante, el salto a dispositivos Android.
El último de los FPS de la lista es Warsow, un clásico juego shooter en primera persona que se encuentra ambientado en un mundo de dibujos animados futurista y donde el jugador tendrá que usar sus habilidades, velocidad y táctica de combate para poder sobrevivir.
La última versión de Warsow fue lanzada en diciembre del 2017 y está disponible para Linux y Windows, en Mac próximamente. Otro juego de acción desmesurada en la lista de los mejores juegos libres GNU Linux para 2018.
Seguimos con un clásico entre muchos adolescentes. Se trata de un clon de Minecraft llamado Minetest: y en el cual nos presenta un mundo virtual donde podremos construir cualquier cosa que se nos ocurra con bloques pixelados de todo tipo.
Su última versión, la 0.4.16, data de junio de 2017 y su versión 0.5 está en camino.
Lo que empezó siendo un simple modificación para Doom 3 se convirtió en una versión de Thief, un juego basado en el sigilo, para luego convertirse en un increíble juego completamente autónomo y respaldado por una amplia comunidad de usuarios. De esta forma The Dark Mod ya nos ofrece un completo set (motor, texturas, modelos y un editor) para crear nuestros mapas y compartirlos con todo el mundo. Vía: Wikipedia The Dark Mod.
La versión 2.05 fue lanzada en febrero de 2017 con nuevas misiones, mejoras para altas definiciones de pantalla, mejoras en la iluminación, etc.
Llegamos ahora a un juego muy simple pero tremendamente adictivo basado en el clásico Worms. En esta ocasión, en Hedgewars utilizaremos erizos rosados en lugar de gusanos en este videojuego de estrategia por turnos con el objetivo de derrotar al resto de equipos participantes usando diversas armas, herramientas y la ventaja táctica del terreno. Vía: Wikipedia Hedgewars
Este año han llegado a la versión 0.9.23 el pasado noviembre con un nuevo modo de juego, nuevas armas, nuevas habilidades y mejoras en las pantallas de las estadísticas.
Seguimos con OpenTTD, un juego de simulación de código abierto basado en el videojuego Transport Tycoon Deluxe (1995) de Chris Sawyer, el cual tiene una mecánica muy simple: llevar una una carga del punto A al B con fin de obtener el máximo dinero posible por su transporte. Vía: Wikipedia OpenTTD
Su última versión fue lanzada la pasada nochebuena, es decir, el 24 de diciembre y con ella se alcanzaba la numeración 1.7.2. Un juego que no puede faltar en la lista de los mejores juegos libres GNU Linux para 2018.
Y seguimos con los simuladores con este de vuelo que no tiene nada que envidiar a los de privativos, al menos en cuanto a física se refiera. FlightGear Flight Simulator utiliza openGL como motor gráfico y los datos de otro proyecto libre: OpenStreetMaps. Vía: Wikipedia Flightgear
Este año ha alcanzado la nueva versión (2017.3.1) el pasado mes de marzo con pequeñas mejoras en este gran simulador.
Y finzalizamos el repaso de la lista de los mejores juegos libres GNU Linux para 2018 con Supertux, una versión del clásico de las plataformas, SuperMario, en el que controlamos a Tux y en la que viviremos horas de aventuras con él.
Este año su desarrollo se ha centrado en la resolución de errores aunque también se han optmizado mapas, fondos y sprites.
Finalmente, me han aparecido 16 juegos en una lista que sí son todos los que están, pero que no están todos los que son. Una lista de juegos de calidad y que colman sin problemas la alma jugona que llevamos dentro y que demonta el mito de que en Linux no se puede jugar.
¿Crees que falta agún juego imprescindible en la lista? Ponlo en los comentarios y lo voy añadiendo.
|
|
Los desarrolladores de Latte Dock, posiblemente la barra de tareas más completa de Plasma 5 y que se está haciendo un hueco entre los usuarios del escritorio de la Comunidad KDE, están trabajando en la nueva versión. Y una de las novedades es que Latte Dock tendrá pieles descargables para su personalización.
Como ya dije en el blog, Latte Dock es una creación conjunta de los desarrolladores de Now Dock y Candil Dock, psifidotos y @audoban respectivamente, los cuales colaboraron para crear esta barra de tareas de aspecto excelente aspecto y funcionalidades y personalizaciones asombrosas y crecientes. Este resultado fue posible gracias a la inestimable ayuda gráfica de @varlesh, que ha dotado al proyecto de un diseño propio espectacular.
La noticia, aparecida en Reddit, es que la próxima versión de Latte Dock tendrá pieles descargables desde la Store de KDE. De hecho, en el momento de escribir el presente artículo, ya nos encontramos con un par de skins en la categoría que se ha creado para este nuevo aspecto de personalización de Latte Dock.
Además se ha presentado incluso la pantalla de descarga de pieles, la típica del entorno de trabajo Plasma.

Aunque os aconsejo visitar la página oficial de Latte Dock para ver todas las funcionalidades detalladas, aquí os hago un pequeño resumen:
En definitiva, Latte Dock se postula como una de las alternativas más espectaculares del entorno Plasma 5 de la Comunidad KDE, un ejemplo más de las infinitas posibilidades de este gran proyecto.
Lo podéis encontrar tanto en la Store de KDE como en Github.
|
|
The 5th and final bugfix update (5.11.5) of the Plasma 5.11 series is now available for users of Kubuntu Artful Aardvark 17.10 to install via our Backports PPA.
This update also includes an upgrade of KDE Frameworks to version 5.41.
To update, add the following repository to your software sources list:
ppa:kubuntu-ppa/backports
or if it is already added, the updates should become available via your preferred update method.
The PPA can be added manually in the Konsole terminal with the command:
sudo add-apt-repository ppa:kubuntu-ppa/backports
and packages then updated with
sudo apt update
sudo apt full-upgrade
Upgrade notes:
~ The Kubuntu backports PPA includes various other backported applications, so please be aware that enabling the backports PPA for the first time and doing a full upgrade will result in a substantial amount of upgraded packages in addition to Plasma 5.11.5.
~ The PPA may also continue to receive updates to Plasma when they become available, and further updated applications where practical.
~ While we believe that these packages represent a beneficial and stable update, please bear in mind that they have not been tested as comprehensively as those in the main Ubuntu archive, and are supported only on a limited and informal basis. Should any issues occur, please provide feedback on our mailing list [1], IRC [2], and/or file a bug against our PPA packages [3].
1. Kubuntu-devel mailing list: https://lists.ubuntu.com/mailman/listinfo/kubuntu-devel
2. Kubuntu IRC channels: #kubuntu & #kubuntu-devel on irc.freenode.net
3. Kubuntu PPA bugs: https://bugs.launchpad.net/kubuntu-ppa
|
|
Mientras estamos cerca de Plasma 5.12, que será LTS y saldrá si no hay imprevistos el 30 de enero, empezamos a tener destellos de algunas de las novedades que nos ofrecerá la siguiente versión del entorno de escritorio de la Comunidad KDE. De esta forma, ayer supimos que Plasma 5.13 ofrecerá una mejor integración con el navegador, una funcionalidad que hará más completa la experiencia de usuario.
Gracias al canal de youtube de The KDE Community nos llega un pequeño adelanto de lo que nos ofrecerá Plasma 5.13, la nueva versión del entorno de trabajo de KDE que todavía no tiene ni fecha de salida.
De esta forma, y a lo largo de poco más de un minuto, vemos que el explorador web va a tener una gran integración en esta decimotercera versión.
Haciendo un resumen tendremos que:
De esta forma, si no lo has hecho ya, no tardes en hacerlo y aportar tu granito de arena en forma de donación (o de promoción de la campaña). Toda contribución, por pequeña que sea es importante… y recuerda la recaudación finaliza el 5 de enero ¡No te despistes!
¡ Ayúdanos a construir un mundo en el que todos tengan control sobre su vida digital y disfruten de libertad y privacidad!
|
|
We are happy and proud to announce the immediate availability of Zanshin 0.5.0.
After 0.4.0 one year and a half ago and 0.4.1 last year (which wasn't publicly announced), this new release introduce new features. The 0.4 series was mostly about the Qt 5 port and stabilization, now we can be a bit more ambitious again.
So what's in store for that new release?
Under the hood, we also did some improvements:
So quite a lot of nice things in this release. We increased the features and polish of what you experience while improving the code base itself. All in all, this should be a very nice release.
As usual, you can grab 0.5.0 while it is fresh! Packages for KDE Neon and openSUSE Tumbleweed are already available, it's only a matter of time until the other distributions catch up.
|
|
Plasma 5.11.5 KDE Neon
https://www.kde.org/announcements/plasma-5.11.5.php
Now available in KDE Neon User Edition!
After a very long time, the KMyMoney development team is about to start the release cycle for the first release of its personal finance manager application based on KF5/Qt5. Various reports show us that people are already using the master branch in their production environment, as several team members have also done for at least …
|
|
Community Goals Over the second half of 2017, KDE has been going through the ambitious effort of having its community propose and choose goals for the next 3-4 years. These goals have been set now, and I was thrilled to learn that my proposal on Streamlined onboarding of new contributors was chosen and many other KDE contributors believed this was a goal worth pursuing in the near future and voted for it.
First of all: Happy New Year! Second, I think that I need to update you on Atelier and AtCore. There are about two months now that AtCore reached its beta stage and we release it with the test client. On my Docker Hub account, the image of AtCore(Master and Beta) was pulled more than 30... Continue Reading →
After a beta version in September and a release candidate in October, there is finally a release of KBibTeX 0.7.
A tag has been set and tar balls have been published.
The only changes compared to the release candidate are attempts to fix online search issues with Google Scholar and IEEE Xplore.
( Read more... )KDE’s Visual Design Group recently put some thought into shadows in Breeze. Right now, the default shadows are rather small, and can be almost entirely invisible on the left edge:

We decided to make them larger and deeper by default, and center them horizontally so that there’s a shadow on the left edges of windows and menus as well. I was honored to produce the patch, and I’m happy to report that it’s been accepted and merged! Starting in Plasma 5.12, here’s how shadows will look:

These are just default settings of course; if you don’t like big shadows, you can tweak to your heart’s content (System Settings > Application Style > Window Decorations > [click on the little menu button in the corner of the Breeze entry] > Shadows). But this new default setting provides a much greater sense of depth that I think most users will find quite welcome.
|
|
FreeBSD is getting more serious about license metadata in the packages produced by the project — that is, the binary distribution of software produced from licensed source code. A lot of software in FreeBSD “proper” is (naturally) BSD-licensed, and a lot of Free Software packaged by FreeBSD is (also naturally) GPL licensed. But the different licenses carry different obligations, so it’s good to keep track of the exact licensing applied to each bit of software.
To this end, there’s the LICENSE= line in each port’s Makefile. Its meaning is “this software has such-and-such a license”. For conciseness, SPDX identifiers are used, so that you can write
LICENSE=LGPL21
and we know what you mean. Because licenses can carry textual obligations (e.g. the GPL expects you to receive a copy, and the BSD licenses generally require you to include the copyright notice with distributions), there’s
an additional setting to include the actual text, called LICENSE_FILES:
LICENSE_FILES=COPYING.LIB
There’s a third source of license information, and that is the headers of the sources themselves. Usually you put a copyright-and-license header at the top of each file; some licenses such as the MPL even require some administration in there. The reuse.software site (by the FSFE) provides good guidance and best-practices information for providing licensing metadata in software packages.
Anyway, for KDE Frameworks 5 I was going through the ports Makefiles and adding LICENSE information. The KDE Licensing Policy tells me that frameworks should be licensed LGPL21+, with a few variants allowed; an interesting one is (at your option) “LGPL21 or LGPL3 or any later version approved by KDE e.V.” Right now, in 2017, this choice is the same as LGPL21+ because no later versions exist, but it is not always-in-the-future-same, so I hesitate to write
LICENSE=LGPL21+
for KDE Frameworks until I’ve checked the files. The license text is usually included, but it’s not quite consistently named, so I need to look into the tarballs anyway. And as a double-check, I read a couple of source headers to see if the license named in the code, matches the license text elsewhere (e.g. some files say LGPL 2.1 only).
It’s a bit of a slow process — one which upstream (that is, the source code) could support a little better with consistent naming. It’s also a process that needs to be monitored continually, to ensure that the whole body of software remains properly and consistently licensed — hopefully following best practices, too.
Anyway, as of today only ten of the KDE Frameworks 5 ports in the official FreeBSD ports repository have all their licensing information set, to the best of my ability to check their accuracy. As an ongoing project in keeping-license-info up-to-date it’s not very high-priority but something that gets done in-between other things.
Challenges with cloud messaging for embedded devices has inspired the Kaltiot & SnowGrains teams to create a cross-platform Qt API which enables easy push messaging from and to embedded devices. The API is called the Qt Cloud Messaging API and it is built with flexibility and extensibility in mind.
We have decided to target other Qt areas, too, and make the API easily extensible to any service provider instead of being for embedded only. This enables developers to use the same API for both mobile and desktop development.
There is a vast number of push messaging providers for mobile and web development nowadays. Yet in industries like automation, automotive, robotics and for other embedded devices there has not really been any providers for this type of service. The need is increasing at a rapid pace as embedded and IoT devices are pushed more and more messages by the device owners, car service providers, telemetry, cloud and many others.
The Qt Cloud Messaging API is simple to adopt and take into use.
Let’s take a sneak peek at how to utilize the API for embedded systems and Android mobile platforms. We’ve integrated the Kaltiot Smart IoT SDK and the Firebase C++ SDK into the backend, and with the Qt Cloud Messaging API we can easily create e.g. a chat application on top of it.
Kaltiot Smart IoT is a service for scalable and secure messaging between devices and services. It provides bi-directional and always online, yet battery optimized communication. The client SDK is designed to work even in constrained low-end devices in poor wireless network conditions. Kaltiot Smart IOT is available for Linux32, Linux64, Raspberry Pi, Mac, Android.
First, clone the qtcloudmessaging repository: git clone https://codereview.qt-project.org/qt/qtcloudmessaging
Service provider
Pre-requirements:
#include <QtCloudMessaging> #include <QtCloudMessagingEmbeddedKaltiot>
// Instantiate CloudMessaging library
QCloudMessaging *pushServices = new QCloudMessaging();
// Add provider for Kaltiot Embedded systems
QCloudMessagingEmbeddedKaltiotProvider *kaltiotPushService = new QCloudMessagingEmbeddedKaltiotProvider()
// Provider based init parameters are given with QVariantMap
QVariantMap provider_params;
provider_params[“API_KEY”] = “Your API key from the Kaltiot console for server communication”;
// Creating name for provider which can be used cross your app.
pushServices->registerProvider(“KaltiotService”, kaltiotPushService, provider_params);
QVariantMap client_params;
client_params[“address”] = “IOTSensor1”;
client_params[“version”] = “1.0”;
client_params[“customer_id”] = “Kaltiot”;
// Creating default channels to listen
QVariantList channels;
channels.append(“weather_broadcast_channel”);
client_params[“channels”] = channels;
// Connect IoT sensor client to system
pushServices->connectClient(“KaltiotService”, “IOTSensor1”, client_params);
//! Automatically subcribe to listen one more channel e.g. WindInfo.
pushServices->subsribeToChannel(“WindInfo”, ” KaltiotService “, ” IOTSensor1″);
6._ Provide context of cloud messaging to QML in main.cpp
//! Provide context to QML
engine.rootContext()->setContextProperty(“pushServices”, pushServices);
QML Part:
in main.qml catch the messages coming from the Kaltiot service.
To receive the message in QML:
Connections{
target : pushServices
onMessageReceived:{
//! Message is received as string and needs parsing to JSON
console.log(message)
}
}
//! Sending a broadcast message e.g. from the weather station:
//! Message structure for embedded devices is easy:
//! define payload json:
//! {
//! “payload_type”:”STRING”,
//! “payload”: encodeURI(JSON.stringify(payload))
//! }
//! Payload is your application specific. E.g:
var payload =
{
msgType:”NEW_WEATHER_INFO”,
city: “Oulu”,
forecast: “full sunlight for whole next week”
}
//! Capsulate payload to message and send it via QtCloudMessaging API:
var payload_array = [{“payload_type”:”STRING”,”payload”: encodeURI(JSON.stringify(payload))}]
pushServices.sendMessage(JSON.stringify(data), ”KaltiotService”, ”IOTSensor1”, ””, ”weather_broadcast_channel”);
Using the Qt Cloud Messaging API for Android / iOS mobile development with Google Firebase service provider
Pre-requirements:
DISTFILES += \android/google-services.json
Define Google firebase path into your application.pro file with GOOGLE_FIREBASE_SDK
#include <QtCloudMessaging>
#include <QtCloudMessagingFirebase>
// Instantiate CloudMessaging library
QCloudMessaging *pushServices = new QCloudMessaging();
QCloudMessagingFirebaseProvider *firebaseService = new QCloudMessagingFirebaseProvider();
QVariantMap provider_params;
// Server API key is not recommended to store inside to the application code due security reasons.
// But if you do, make sure it is inside compiled C file or if you are doing a server side implementation with C++ & Qt.
// SERVER_API_KEY Is needed to be able to send topic messages from the client without Firebase application server.
provider_params[“SERVER_API_KEY”] = “Get your SERVER API KEY from the google firebase console”;
// Registering the Google firebase service component.
pushServices->registerProvider(“GoogleFireBase”, firebaseService, provider_params);
/*! Connected client is needed for mobile device.
\param Service name “GoogleFireBase”
\param Client identifier name to be used inside the application
\param Parameters for the client. No params for firebase client.
*/
pushServices->connectClient(“GoogleFireBase”, “MobileClient”, QVariantMap());
//! Automatically subscribe to listen one example topic
pushServices->subsribeToChannel(“ChatRoom”, “GoogleFireBase”, “MobileClient”);
6._ Provide context of cloud messaging to QML in main.cpp
//! Provide context to QML
engine.rootContext()->setContextProperty(“pushServices”, pushServices);
QML Part:
in main.qml catch the messages coming from the google firebase
Connections{
target : pushServices
onMessageReceived:{
//! Message is received as string and needs parsing to JSON
console.log(message)
}
}
//! For firebase, message structure needs to have data as whole message.
//! Notifications are shown in the Android/iOS notification center.
function sendMessage(notification_titile, notification_msg, msg){
var data = { “data”:{
“message”: {“text”:msg } },
“notification” : {
“body” : notification_msg,
“title” : notification_titile
}
}
//! Give data and service provider identifier as well as client name defined in the C++ code.
pushServices.sendMessage(JSON.stringify(data),”GoogleFireBase”,”MobileClient”,””,”ChatRoom”);
}
You can play around with the Qt Cloud Messaging API + firebase from the sample
https://github.com/snowgrains/qtcloudmessaging-examples
The Qt Cloud Messaging API provides cross-platform API to enable us to include new providers and still keep the development API as same.
The Qt Cloud Messaging API has been developed to be easily extensible to any service provider. Take a sneak peek at ongoing development from the https://codereview.qt-project.org/qt/qtcloudmessaging and contribute your own backend service to the community.
Kaltiot has been developing and hosting IoT cloud services since 2008. Trusted e.g. by Microsoft, Kaltiot passes through 10M messages every hour. (www.kaltiot.com)
SnowGrains provides Full Stack Software Solutions On The Rocks.(www.snowgrains.com)
Ari Salmi is multi-technology developer and Qt enthusiast.
The post Qt Cloud Messaging API Available for Embedded Systems appeared first on Qt Blog.
Good evening fellas,
Happy New Year to all! The year 2017 has been a rollercoaster, to be honest. Well, it was rich and prosperous year regarding in technical terms. It was a beautiful year of great learning, splendid travel and got to network with some fantastic folks all around the globe.
The best reason for making this 2017 incredible for me is KDE. One of the exciting community I have ever seen! It all started at the end of 2016, I got intrigued by the Tagline of KDE, “Experience freedom”. I started contributing to various projects inside KDE. My initial start was with Konsole, system settings, KIO and various educational suite programs. Moving on, I came across a student program organized by KDE named KDE-SoK and I was selected for it, yay!!!
The project was with KStars(KDE’s amateur astronomy software which provides real-time and an accurate graphical simulation of the night sky, from any location on Earth.) to collect a new set of images from NASA/ESO catalogs along with orientation and pixel scale (arcsecs/pixel) from the whole set of Messier Catalog (which is a collection of 110 astronomy objects in the night sky). Images were processed for overlay in KStars using OpenCV, so to have transparency and to modulate according to the software.
After the successful completion of the project, I was invited as a speaker to give a talk on “Object-Tracking Using OpenCV and Qt” at KDE India Conference held at IIT Guwahati in March 2017. Again, yay!! :P. There I met a lot of enthusiastic KDE people out there. 
Later on, I was selected as a Google Summer of Code (2017 edition) intern funded by Google. I contributed to Krita(Krita is a professional and open source painting program) of KDE. The project was to Integrate share.krita.org.
Share.krita.org is a place where users can share Krita scripts, images, brush packs and more. This project has two parts: integrate with the KNSCore part of the KNewStuff framework (or reimplement the protocol) and create a GUI for sharing. The second part is improving the support for creating and editing bundles. Bundles can contain brushes, patterns, gradients and so on. Also, Krita needed basic support for creating and editing bundles.
Thus said, the entire journey with KDE last year was splendid!! The community as such is a group of awesome and enthusiastic people from all around the globe. To do more than I could last year — I hope to be a part of this great venture in 2018.
Here’s to a productive year, and looking forward to the same in 2018. You can see more of what happened in KDE in 2017 on the KDE year-end fundraiser page. Please do show some of your support to the community and its developers through the fundraiser to built your favorite software 
Some of my blog post regarding my work last year:

To the awesome year coming right your way,
Cheers.
At the beginning of 2017, I was a programmer (mostly Python, and a little bit of C++) and spent most of my day at my desk, with an IDE open and a cup of coffee at hand. At the end of 2017, I’m a programmer (mostly C++, and a little bit of Python) and spend most of my day at my desk, with an IDE open and a cup of espresso at hand.
At some level of abstraction, not much has changed this year.
Of course, now I spend my entire day working on Free Software, in three different but partly-overlapping communities: KDE, FreeBSD, and Calamares. Basically you can track everything I do each day by looking in the relevant repositories on GitHub (read-only mirrors in the case of FreeBSD and KDE). Inspired by Michael, Krita, Matthieu Gallien (with the this-week-in-Elisa series) and Dominik Haumann, I’ve collected a list of things I did this year, in no particular order:
Here’s to a productive year, and looking forward to the same in 2018. You can see more of what happened in KDE in 2017 on the KDE year-end fundraiser page.
A central place to track KDE development is the kde-commits@kde.org mailing list. To this mailing list, all code changes are sent, containing the log message as well as the diff that quickly shows what really changed. In the early days of KDE development, the changes were maintained by the CVS version control system. Later, this was changed to subversion. Nowadays, KDE mostly uses git, but some svn modules are still around.
Since KDE is developed by many contributors, the kde-commits@kde.org mailing list obviously has high traffic, ranging from ~100 mails up to 400 mails a day (see marc.info for statistics).
Many developers are subscribed to this mailing list. However, due to high traffic and possibly many changes that are unrelated to your pet project, a commit filter was invented, which was available on https://commitfilter.kde.org for a long time. Essentially, this commit filter allowed to easily setup filters in terms of regular expressions, such that you’d only get mails for changes you are interested in. While this was convenient, the commit filter also had its drawbacks: Instead of getting all KDE changes, you missed a lot possibly interesting conversations: Since post-code reviews are often done by others through email conversation directly on the code changes.
Nowadays, the commit filter is not available anymore, mostly for security reasons since it was unmaintained for a long time.
What does that mean? I’m subscribed to kde-commits@kde.org again, getting all changes. In fact, I am enjoying skimming quickly through the changes, even doing a code review here and there.
I recommend every KDE contributor to subscribe to this mailing list, since it is very interesting to see which projects are actively developed and who really contributes to KDE in person. Even better, sometimes there are discussions on this list, helping you to learn things you didn’t know. Of course, nowadays we also have many code reviews on phabricator, but still the commit mailing list is a nice addon to track KDE development.
The year is about to end and so is Cutelyst v1 series, I wasn’t planning for another release this year but Matthias added some nice new features that I decided to roll 1.12 in 2017 branching 1.x.x series and master is now officially Cutelyst 2 with no stable API/ABI until 2.0.0 is tagged.
HTTP/2 support will hopefully be part of Cutelyst 2.0.0, there aren’t any drastic changes in v2, most important thing is fixing MSVC builds and removing deprecated API.
Back to this release it includes a new CSRF protection plugin, with a Grantlee tag similar to what Django has. Add to this many fixes and the epoll event loop dispatcher is now even faster and got many fixes, performance wise it’s great advantage is when dealing with many simultaneous connections, it can lead to 2-3 times faster than default glib one.
https://github.com/cutelyst/cutelyst/archive/v1.12.0.tar.gz
Happy new hacking year!
Playing with emojis
At some point, I needed to copy paste emojis, but couldn’t find a good way to do it. So what does a good hacker do?
Scratch an own itch. As I wrote about in the past, all these projects should be shared with the rest of the world.
So here it is: https://cgit.kde.org/scratch/sune/aubergine.git/
It looks like this with the symbola font for emojis: 
It basically lets you search for emojis by their description, and by clicking on a emoji, it gets inserted into the clipboard.
As such, I’m not sure the application is really interesting, but there might be two interesting bits in the source code:
And of course, now it is simple to describe fancy cooking:

(aubergine) (hocho) (fire)
I ❣ emoji
Not goodbye, but hello to a new music player on my desktop. It is already packaged for FreeBSD and has a long development history.
Music players stand or fall per individual user whether they satisfy the user’s needs — no duh there, but it means I should note what my use cases are before enthusing about some music player in particular. I would be fine with playing music from the command-line, most of the time: mpg123 --shuffle /mnt/music/*/*/* is just about right (except it fails with an argument list too long error in the shell). This is for music-while-I-hack, so I don’t listen too closely, it’s not hi-fi at all, basically I want “play in a genre until I switch it off“. Tagging is largely done when ripping my CDs (I still buy physical media!) and I don’t care for album art (I can look in the jewel case if I want that, and they’re all stacked in boxes upstairs). So play, pause, stop .. and if it can avoid mixing Mahler with Morrissey and Mötorhead, that’s a bonus.
Off to the left here is Sayonara, which describes itself as:
“Sayonara is a small, clear and fast audio player for Linux written in C++, supported by the Qt framework. It uses GStreamer as audio backend. Sayonara is open source and uses the GPLv3 license. One of Sayonara’s goals is intuitive and easy usablility. Currently, it is only available for Linux.“
Clearly that’s not true, because it’s available for FreeBSD as well
. I forget how I configured it; there’s a File > Open Directory entry and I probably filled in /mnt/music and it went and found everything that gstreamer will sensibly play. The screenshot is of the minimal playlist-only view. It can be broadened to include a library view which is a bit chaotic, but which searches reasonably well (e.g. for Mudhoney). Sayonara is actually where I discovered the luxury of stay-on-genre autoplay: when I started on some Dutch punk and it kept pretty close to that, wandering off to de Kift occasionally — but no Drs.P.
I contributed a few small fixes to get Sayonara building on FreeBSD, cleaning up the CMakeLists for newer CMake, that kind of thing. Now that it runs on my Plasma desktop all day, I can spot some more minor issues — the system tray media player control doesn’t interact with Sayonara at all, for instance. For my use-case, that’s not so important, since the fire-and-forget genre play does it for me until I hit pause in the main UI.
I’m looking forward to KDE music players Elisa and Babe, for comparison purposes: maybe they tick my requirements-boxes just as well, or better. Certainly Elisa seems to be fairly playing-music-focused. I’ve even got a FreeBSD port for Elisa ready, just waiting for Qt 5.9 to show up on my doorstep (I can get it to compile against 5.7, but it won’t run due to QML runtime thingies).
Elisa is a music player designed to be simple and nice to use. It allows to browse music by album, artist or all tracks. You can build and play your own playlist. We aim to build a fluid interface that is easy to use.
I enjoy working on the elisa music player. I hope some people enjoy using it. All of this would not have been possible without the KDE community. There is an ongoing fundraising campaign. Please support it.
https://www.kde.org/fundraisers/yearend2017/
Not much have been done due to Christmas and end of year holidays.
The following things have been integrated in Elisa git repository:
There are also some pending diff request in phabricator.
We have also some ongoing work to organize work with KDE VDG. Some future changes following their feedback is planned.
I am also driving an effort to more clearly communicate what elisa is about (inspired by the work on KDE goals and plasma vision). I hope to be able to also have a vision for elisa and to derive some goals aligned with those of the KDE community.
The CMake port on FreeBSD is in the hands of the KDE-FreeBSD folks (since KDE was an early adopter), and generally it falls to me to do the CMake update while Tobias is still wrestling with Plasma and Raphael massages Qt 5.9 into our way of building. 3.10 was released five weeks ago, and it took a while to update the port.
It doesn’t take long because of CMake — they’re great, the code builds flawlessly, and there has been a real effort on the part of the KitWare folks recently to absorb our downstream patches so that we have less work in future (During the delay packaging CMake 3.10.0 Kitware even put out 3.10.1, which re-started some processes). It doesn’t take long because of new FreeBSD-specific features in CMake — you can now use CPack to create native FreeBSD packages, just in case you don’t want to go through the ports system or poudriere.
Nope, the problem is the 2000-odd ports using CMake. These generally behave, but every CMake update brings with it some ports that suddenly don’t build. So I spent a day on things like openvsp and scalapack, which fall over with 3.10 (and didn’t with 3.9). The causes of these failures is diverse; sometimes bad local CMake modules that don’t add all the right linking flags, sometimes bad C++ code, sometime stuff that has nothing to do with CMake at all but just happens to be newly triggered, and therefore my problem.
CMake 3.10.1 landed in the official ports tree with r457041, just before Christmas.
Naturally, there are some cases that fall out after an update, that are not caught before the update is committed. I’m told that FreeBSD on PowerPC doesn’t have a C++11-capable compiler installed by default, so I’ll need to massage that a little. Boost 1.66 came out very shortly after CMake 3.10.1, and that leads to new kinds of breakage. I’ve spent a half day compiling and re-compiling ceph, a distributed filesystem, trying to get that to work. It’s amazing sometimes how shifting one brick can bring down a whole house, and how we ever built the house in the first place.
First and foremost, 2017 ends well. We will end this year putting Krita 4.0 in string freeze, which means a release early next year! In 2017, we’ve released several versions of Krita 3.x. We’ve gained a lot of new contributors with great contributions to Krita. We’ve got money in the bank, too. Less than last year, but sales on the Windows Store help quite a bit! And development fund subscriptions have been steadily climbing, and we’re at 70 subscribers now! We’ve also done a great project with Intel, which not only brought some more money in, but also great performance improvements for painting and rendering animations.
It’s been a tough year, though! Our maintainer had only just recovered from being burned out from working full-time on Krita and on a day job when the tax office called… The result was half a year of stress and negotiations, ending in a huge tax bill and a huge accountant’s bill. And enough uncertainty that we couldn’t have our yearly fund raiser, and enough extra non-coding work that the work on the features funded in 2016 took much, much more time than planned. In the period when we were talking to the tax office, until we could go public, Boudewijn and Dmitry were supported by members from the community; without that support the project might not have survived.
But then, when we could go public with our problems, the response was phenomenal. At that point, we were confident we would survive anyway, with the work we were doing for Intel, the Windows Store income and private savings, but it would have been extremely tight. The community rallied around us magnificently, and then Private Internet Access (who also sponsor KDE, Gnome, Blender and Inkscape, among others) contacted us with their decision to pay the bill!
From nearly broke, we went to be in a position to start planning again!
We reported about those plans before, but to recap:
Akademy is the yearly KDE community conference, and Krita has always been part of the KDE community. And KDE has always been more than a desktop environment for Linux and other Unix-like operating systems. As a community, KDE offers an environment where projects like Krita can flourish. Every developer in the KDE community can work on any of the KDE projects; the level of trust in each other is very high.
These days, judging by the number of bugs reported and closed, Krita is the second-most used KDE project, after the Plasma desktop shell. Without KDE, Krita wouldn’t be where it’s now. Without KDE, and the awesome job it’s volunteer sysadmins are doing, we wouldn’t have working forums, continuous integration, bug trackers or a project management platform. Sprints would be far more difficult to organize, and, of course, Krita depends heavily on a number of KDE framework libraries that make our coding life much easier. KDE is currently having the annual End of Year Fundraiser!
Our contributor sprint in 2016 was partly sponsored by KDE as well. With all the bother, it looked like we wouldn’t meet up in 2017. But with the project back on a sound footing, we managed to have a small sprint in November after all, and much vigorous discusion was had by all participants, ending up with firm plans for the last few 4.0 features that we were working on. Next year, we intend to have another big contributor sprint as well.
And, of course, lots of lovely releases, bug fixes, features, artist interviews, documentation updates, and the please of seeing so many people create great art!
It’s time for the end of 2017 KDE fundraiser, and so this is good a time as any during the year to take a step back and publish a retrospective on the work we’ve individually done in 2017.
For those maintaining a module or two this isn’t too hard to figure out what you’ve done with some git magic. But if you’ve made contributions to more than a few modules it can be a bit unwieldy trying to figure out what work you’ve actually done.
While it’s probably not too difficult to craft a find(1) command to search recursively under a common directory for git modules, and then run git-log to look for commits with a given author, it can take a significant amount of time to go through that list if you have a set of checkouts like mine.
Instead, I used kdesrc-build to help, using the --query flag I blogged about a few days ago. Using kdesrc-build to query for a source directory isn’t very helpful here compared to raw use of find(1). Rather, it allowed me to allow use kdesrc-build’s own facilities for filtering through modules to build so that I could eliminate git modules I know I’ve had nothing to do with in a way that isn’t as easily expressible using find flags.
In my case, I used a command like this:
kdesrc-build --query source-dir --resume-from extra-cmake-modules | \
cut -f 2 -d ':' | \
while read dir ; do \
[ -d "$dir" ] && cd "$dir" && \
git --no-pager log --since='2017-01-01' \
--pretty="tformat:$(basename $dir): %s" \
--author='mpyne@kde.org' --committer='mpyne@kde.org' ; \
done
What this does is to run kdesrc-build and have it generate its module list as normal, using the --resume-from command to skip over a bunch of large modules I had nothing to do with, and output a line for each of those modules in the form “ki18n: /kdesrc/src/kf5/frameworks/ki18n”.
Each line is fed to cut(1), which prints just the part after the colon (sed(1) would work as well). This path is fed into the while loop, which extracts each input line into the $dir variable, and uses that variable to make sure the directory is actually checked-out and if so, runs git-log in that directory.
Git then actually does the search for any commits since the date given (2017-01-01) by the author(s) or committer(s) you pass. I use the --no-pager flag before the git subcommand so that I don’t have to pipe to cat(1) to avoid the automatic interactive result display.
Finally, I use the --pretty flag to cause git to also include the basename of the directory when it is showing each commit. This helps organize where you did your work in a form that’s easy to slice-and-dice later.
So, what did I do this year? It was split up among these major categories:
uic as ineligible for CMake’s AUTOMOC (fixes a warning of a new CMake policy)While it has been (and continues to be) difficult to find time to make a meaningful impact with a full-time job outside of software development and a growing family, I hope to be at least as productive in the year to come in 2018.
Happy New Year’s everyone and if you have some spare change lying around, please don’t hesitate to support the KDE fundraising drive! Every bit goes to work on something important, and each contribution helps.
KMarkdownWebView 0.4.0 has been released.
Example: KMarkdownWebView KParts plugin used by ArkThe KMarkdownWebView software is for the rendered display of Markdown documents, using web technologies (native wrapper around a webpage with a JavaScript library which creates HTML from the plain text handed in).
The software contains
The KMarkdownWebView KParts plugin is also prepared for improved experience with the KTextEditor Document Preview plugin for KTextEditor-based applications like the editor Kate and IDE KDevelop.
KMarkdownWebView can be built both with QtWebEngine (preferred by the build system) and QtWebKit. Pass -DUSE_QTWEBKIT=TRUE to CMake to enforce the use of QtWebKit.
Download from: https://download.kde.org/stable/kmarkdownwebview/0.4.0/src/
sha256: 38b72ba6fa4b513002e7873d2b774e50d676fc878a38b18e6eb9636b53b4c29d kmarkdownwebview-0.4.0.tar.xz
Signed with my new PGP key
E191 FD5B E6F4 6870 F09E 82B2 024E 7FB4 3D01 5474
Friedrich W. H. Kossebau
kmarkdownwebview-0.4.0.tar.xz.sig
Krita is not widely known in Latin America. In Colombia, we found that people are interested in knowing more about how to use it. This year, in April 2017, the program of the Latin American Free Software Install Fest included a workshop by David Bravo about Krita. The workshop was fully booked and inspired us to create this course.

Left to right: Mateo Leal, Angie Alzate, David Bravo (teacher), Lina Porras, Lucas Gelves, Juan Pablo Sainea, Javier Gaitán
During 4 sessions of 3 hours each, David Bravo guided a group of six students through their first steps in Krita, including sketch, canvas, digitalization, lines, curves and brush, light and shadow, digital color, painting and color palette, texture, effects, exporting files for digital media and printing.

David Bravo (front). The projected drawing is his work.
This course was made possible by the cooperation of three organizations: Onoma Project, Corre Libre Foundation and Ubuntu Colombia. The cost for the students was about 16 USD; all of the proceeds were donated to the Krita Foundation.

Lucas Gelves teaching himself to draw.
We think that we can offer an intermediate course in 2018. And of course we want to say thank you to the Krita Foundation for sending gifts for the course students and for staying in touch with us. We hope to cooperate in the near future for future courses!
David Bravo is a digital and multimedia designer from Colegio Mayor de Cundinamarca, currently working in multimedia freelance projects with a focus on traditional animation, 3D and visualization in virtual environments. He is also the leader of the Onoma Project, an online free platform that is under development. The main objective of this project is to provide tools for easy and secure learning of FLOSS for design.
Ubuntu Colombia acts as coordinator and communicator of the course. Ubuntu Colombia is a community with 12 years of history in spreading Ubuntu and FLOSS in Colombia; the Krita course was part of this year’s efforts of the community to promote education on FLOSS tools, as were LaTeX courses and LPIC preparation courses.
Corre Libre Foundation is an NGO created in 2008. Its objectives are:
– to promote the creation of free/open knowledge
– to sponsor free technological projects with social impact
– to promote and spread the use and development of technologies that contribute to human freedom
– to promote and spread collaborative work.
They support Orfeo, which is documentary software. For this course they provided a place to work, which would otherwise have been too difficult and expensive to find in our city.
Remember to donate to our End of Year fundraiser and support our community and its work.
It's the time of year for recaps. We already talked about the advancements in KDE's software, and it makes sense we talk about that first. To many people and for many years, "KDE" was synonymous with a desktop environment and its applications. That is, KDE was its software.
However, these days “KDE” stands for the community and the work we carry out – and that is more than just code. KDE sponsors students and budding developers, meets in events and works in sprints. All of this ultimately, yes, helps KDE produce more and better software. But more importantly, it encourages a large number of people to work together for the common good.
With that in mind, here goes our tribute to the larger KDE community and the landmarks reached in 2017:

Anu visits Akademy.
Photos by Anu Mittal.
New developers and students were brought into the KDE fold in 2017. We showed them how to start contributing to Free Software, opened up career opportunities for them, and helped them realise their full potential.
Among other things, this year we sponsored 24 students who have participated in the Google Summer of Code. Their projects ranged from developing new tools for existing apps, like the new heal tool to remove dust and scratches from photos added to DigiKam, or the possibility of exploring indoor plans to Marble; to improving libraries to adapt to new technology, like the library that allows KDE apps to make the most of High-DPI monitors, or the Brooklyn bridge that allows Instant Messaging users to communicate with other users using different IM systems.
KDE also sponsored developers and supporters to allow them to visit events far from their homes. We helped Lays Rodrigues from Brazil get to the developer sprint we run every year in Randa, Switzerland. Lays is working on Atelier, a graphical interface for controlling 3D printers.
A sponsorship for Anu Mittal (a software engineer) and Vasudha Mathur (a student software engineer) allowed them to make it to Akademy in Spain all the way from India. Anu is a contributor to several applications in KDE's educational suite of programs, and Vasudha is writing a Qt interface to Rocket Chat, a free, open source team chat system for enterprises. Vasudha's implementation will work both on desktop and mobile devices.
Talking of Akademy...
This year the KDE community met in full force in August in Almería, in the south of Spain. Akademy provides all KDE contributors the opportunity to meet in person to foster social bonds, work on concrete technology issues, consider new ideas, and reinforce the innovative, dynamic culture of KDE. Akademy brings together artists, designers, developers, translators, users, writers, sponsors and many other types of KDE contributors to celebrate the achievements of the past year and help determine the direction for the next year.
This year's event attracted over 110 attendees travelling mainly from Europe, but also from North and South America, and Asia. Over the weekend, visitors were able to attend more than 40 different talks on all kinds of topics, ranging from developing applications for mobile phones to best ways for collaboration between communities.
And then, thanks to our sponsors and donations from community members, KDE developers assembled again in Randa, Switzerland, ready to tackle the challenges of accessibility. Voice feedback and keyboard navigation got added to Plasma, Marble got smoother and developers started working on a better text-to-speech engine for the mapping app. The developers also discussed accessibility best practices and decided testers should check if an app can be used only with the keyboard and then only with a mouse. They also agreed that customizations should be kept to a minimum. In summary, KDE developers made everything better for everybody.
The Qt World Summit (QtWS), held in Berlin in October, was a meeting of another kind altogether. Our target at this event was to convince people from enterprises and a wider developer community to Power Up using KDE-based libraries and framework. Visitors could try Plasma Mobile working on an actual handset, and also play with the upcoming Pinebook, a Plasma-enabled ultra-notebook built around the Pine 64 SBC. Attendees could also recharge literally, relaxing at our ample sitting space with comfy cushions in an open and informal atmosphere, while topping up the batteries of their devices with the plugs and USB charging stations strategically placed all around the sitting area. Our aim was to make visitors feel welcome not only to our booth, but also to our community.
But helping people discover Free Software by discovering KDE is only one of the ways we helped further FLOSS in 2017...
We supported the cause for a wider adoption of Free Software in several ways during 2017. We partnered with Purism to work on getting Plasma Mobile ready for their Free smartphone, Librem5. We are proud that KDE's early participation in the crowdfunding campaign was instrumental in pushing it over the finishing line and then some. Not only did we help them surpass their initial goal of $1.5 million and then reach 2 million dollars, but we also precipitated a flurry of endorsements from other Free Software projects, such as Gnome and Monero. The end result is that a fully open and privacy-respecting Linux-based phone is much nearer than you think.
And then we helped the Free Software Foundation Europe campaign push for increased adoption of Free Software in public institutions. The Public Money? Public Code! campaign advocates for software developed using public funds to be released and shared under Free Software licenses. We raised awareness by blogging about it, and published an article about the campaign here, in the Dot. We then spread the news through our social media accounts.
Talking of which...

Mastodon became our favorite way
of meeting new people in 2017.
It has been a good year for growth of the KDE community. We have ramped up our activity on social media to help more people become aware of the benefits of Free Software in general, and of KDE environments and applications in particular.
Our Twitter following has swelled to well over 51,000 users, and our subreddit now has more than 10,000 subscribers. This is a massive audience that re-tweets, comments and posts about what we do, helping us reach an evergrowing audience. We have also increased our presence on Facebook and G+.
But probably the most interesting social network we started using in 2017 is Mastodon. We created our account on this free and federated microblogging network back in July, and have seen our audience grow along with the service itself. We are currently averaging 17 new followers a week and have recently surpassed the 500 mark.
Thanks to these outlets, we get to talk to more and more people every day. Our social media accounts allow for a two-way conversation with users we would otherwise never hear from.
Although it may sound trite, the long and short of it is that KDE nowadays is more about people than about writing code. Of course, we love our software and adore the talented developers, but we see beyond developing apps and environments. We consider our technology a force for good; a way to help bring usable, accessible and powerful software to the people.
Over the years, we have discovered that we need more than excellent developers to do that. We need a whole community willing to contribute a wide variety of skills, technical and otherwise. Fortunately, KDE has managed to build a strong community, and it is thanks to you and people like you. None of the above milestones would have been possible without your support and your contributions. You can help us even more by donating to our End of Year fundraiser or by spreading this article far and wide, raising awareness of the work we all do together.
Thank you because you made 2017 wonderful, and thank you again because we know you'll make 2018 even better.
Bystander.
It seems such a passive word for a passive role.
Let's consider how it is instead a position of power.
First, as a bystander, I can observe what is happening which nobody else sees, because nobody else is standing exactly where I am. Nobody else has my mix of genes and history and all of what makes me who I am and so I see uniquely.
As bystanders each of us has power we often do not grasp. It is of the moment. We can plan, and prepare so that we are ready to act, intervene if necessary; build up potential energy. While remaining polite, I can step in to help, intervene, participate, engage. I can ACT.
Pro-tip: run this program (courtesy of the Linuxchix:
1. be polite
2. be helpful
3. iterate
Boom! You have a team.
Supporting free software is one of the things I do. Right now is a great time to help support KDE.
KDE Powers You - You Can Power KDE, Too!
https://www.kde.org/fundraisers/yearend2017/
Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.