Implementing Qt data models is anything but fun.
For that reason,
I don’t blame anyone for writing a
beginResetModel / endResetModel
combo any time a more complex change has happened.
That is something that we all do,
that is something that even Qt people do in their classes
(see QSqlTableModel::select for example).
Resetting a model is an expensive process
that can induce overly many transition animations in QML views.
And it is often not really necessary.
Updates are rarely that complex to warrant
invalidation of all data in the model.
Usually, they only consist of a few additions or removals.
As I’ve already mentioned,
KActivities are now on KDE’s Phabricator.
One of the things I really did not like about our todo.kde.org service is that
in order to use the API to get your tasks and projects, you need to have
administrator privileges. Therefore, no sane tool actually supports it.
Phabricator is much nicer in that regard.
It has a nice API, and it even has a Python module which can be used to
retrieve anything that you’d want it to.
The first thing I wanted is to pull the issues and review requests from Phabricator
into the TaskWarrior
(if you still do not know what TW is, you ought to investigate it right this instant).
There is an external tool called BugWarrior
that is able to get the tasks from a range of different services
like github, jira, bugzilla (does not work with bugs.kde.org) and others.
Fortunately, it also supports Phabricator.
If you haven’t heard,
there are a few KDE projects testing Phabricator
for patch review and project management.
KActivities are amongst those.
So, from now on, if you want to provide patches,
you are advised to do that through http://phabricator.kde.org/
and the Arcanist tool instead of the ReviewBoard.
We are also going to organize our work tasks on Phabricator
instead of todo.kde.org.
The ultimate goal is to test whether Phabricator is a viable
alternative to a few of our services.
In the beginning, I used Blogger.
But it was limiting,
and had its share of problems.
After a while, I decided to use my own host (ivan.fomentgroup.org)
and switch to a mixture of Folite (a small CMS I wrote for my other sites)
and WordPress (for the blog section).
This combination has provided my online presence (to use the marketing-speak :) ) since 2009.
During that time, WordPress started becoming a huge beast
that I had to reinstall quite a few times,
and each time to triage which plugins broke it.
WP has streamlined its interface, the admin section and everything,
but it is quite difficult to manage if you need to dive into its code base.
So I decided to make a change.
I decided to switch to a new domain (cukic.co) and to new blogging software.
I looked into Ghost (due to Aaron’s recent switch from Blogger to Ghost),
Anchor, Wardrobe and a few other simpler blogging solutions.
They seemed nice, but either needed Node.js,
or something similar that is not supported by my hosting provider;
or they just did not work for some reason.
Then I found Jekyll.
Jekyll is a simple website generator
which allows you to create templates,
different page layouts with all the power of Ruby and Liquid,
to write content in Markdown (and others),
and it generates static html files from those that you then just need to
upload to the server.
I’m almost back from the C++ Russia conference held in Moscow these past few
days. Heading home later today.
I must say that Sergey created a really nice conference, with a carefully
tailored set of talks mostly focussed on parallelism and concurrency.
The conference was opened by Sean Parent, with a keynote somewhere along the
lines of “don’t use raw threads” (after his previous hits like “don’t use raw
for-loops”). It had everything, great examples from the his projects at
Adobe, a few bigger chunks of code, and even abstract scientific parts related
to flows in graph theory.
And that was just the beginning.
It was followed by Zoltan Porkolab’s talk on debugging and profiling C++
meta-template programs. Fantastic talk that deserves a separate blog post since
it can make a lot of TMP-related headaches go away. I’ll write it one of the
following days, when I get my bearings.
It was also a pleasure to listen to Bartosz Milewski talking about category
theory and presenting monads in quite an interesting way; Rainer Grimm on how to
cope when you need to use the lower-level concurrency primitives; and Guntram
Berti on how to properly write your generic code.