Finding the Unloved, in the Valentine’s Day. February 15, 2013
Posted by tumaix in planetkde-tomazcanabrava.2 comments
Open Your Hearts, Tt’s Adoption Time.
It’s 2013, and the world didn’t end last year like the scientific prediction of a holywood movie.
Unfortunately, not everyone scaped, it seems that while the world didn’t end literally, a lot of developers have abandonned their children, their beloved apps and went to the city of Caracol to survive the mayan’s holywood prediction, and have not ever appeared back.
This left us with a bunch of applications that are in need of someone to care for them, to hug them at night and say that everything’s gonna be all right. But we lack the manpower for that, and that’s why we are asking your help to revive some applications, that are waiting ( some of them for years ) to have people working with them again.
Some applications are used by people everyday, but no one is taking care of fixing stuff, implementing new stuff, porting things, improving it to the new decade that’s comming in.
If you are a developer and remember of an application that’s abandoned, please put it in the wiki, if you remember of something that can be done with it, also add as an GSoC 2013 idea’s page. The whole world will thank you, and you will not make baby konqui cry.
If you are interested in taking care of an application and are ‘just’ a student, a hobbyst or don’t program for a long time, fear not, because you will join an amazing community of friends, coders, artists, programmers, shrinks, animal lovers and popcorn ( because I like popcorn ). You will increase your programming skills and work with state of the art developers like Aaron Seigo, David Faure and Thiago Macieira ( and many, many others ) that are behind KDE, Qt and the blue universe itself.
ps. And helping it will make you a great person, and because it’s Valentine’s, remember that only one thing matters if you are in love:
QtMof/QtUml: XMI serialization and metamodel plugins January 21, 2013
Posted by Sandro Andrade in planetkde-sandroandrade, planetqt-sandroandrade.1 comment so far
Hi there,
A lot has happening since my last post about QtMof/QtUml - a Qt5 add-on module devoted to (meta-)modeling and model-driven support in Qt (currently in Qt Playground). Auto-generation of meta-models has been further improved, making of use Qt5′s new features for metatypes, XMI serialization is already in place even though not all specified configuration parameters are currently supported by now. In addition, QtUmlEditor example has been a full testbed for QtMof/QtUml and can probably be useful as a working application afterwards.
Meta-models (like MOF and UML) are now implemented as Qt plugins. That enables editor (and XMI serializer) to be fully independent from modeling language and also sets the stage to deal with user-defined meta-models. We are currently implementing the OCL (Object Constraint Language) parser which will allow users to define and execute ‘sanity checks’ and conformance rules on models. That will also enhance auto-generation of meta-models since a lot of operations and derived properties can indeed by specified in OCL (as already happen in Uml meta-model).
How to try it !
- From sources: http://qt.gitorious.org/qtplayground/qtmof
- openSUSE repositories: http://download.opensuse.org/repositories/home:/sandroandrade/
- ArchLinux: you can build it from AUR (yaourt -S qtumleditor) or download and install the following packages (OBS-generated Arch repositories are slightly broken by now):
- Windows x86_64 package: wiki.ifba.edu.br/qtumleditor/qtumleditor.rar
Contribute !
As usual, any help with testing, developing, and reviewing is quite welcome 
Maybe we can expect some model-driven features in QtCreator and KDevelop in a near future ?
See you …
2012 Recap for me in KDE. January 2, 2013
Posted by tumaix in planetkde-tomazcanabrava.1 comment so far
2012 is not the best year for me in the KDE team, I almost didin’t coded, heal life issues keep me busy in a way that I couldn’t avoid. I did a few things however:
- The program that I started as an University Project back in 2008, Rocs, is now being used in universities around the world for teaching Graph Theory and Data Structures. ( Much thanks to Andreas (CoLa) and Wagner Reck ( wiglot ) for helping me on improve my initial mess into a true opensource project. If you are a teacher or computer scientist student and never heard of Rocs for Data Structures / Graph Manipulation, do a favor for yoursellf and go take a look.
- I’v spend this year much money on KDE related stuff: Bougth one kick ass Konqui Costume ( that costed around 2,200 EUR, + shipping ) and 2k buttons with konqui paintings to be used everywhere in events. It was used sucessfully in FISL and LatinoWare, the two biggest events in latin americas ( one with around 8k participants and the other with around 5k ). The konqui costume was partially sponsored by Blue Systems ( Thanks o/ ), the company that sponsor the work of Aleix Pol and other great KDE hackers.
- I’v Been into the two more importants events for KDE in the latin americas, the LaKademy and FISL, LaKademy was the one place that I hacked, tought. It was done primarely to tight the community in the latinamericas – One thing that I like very much is that the people in KDE-BR is like a family, Sandro, Aracele, Filipe, Lamarque, Wagner, Me, Camila, Henrique. We didn’t know anyone, KDE introduced us all, now we all are friends and BFF’s. <3
- I’v tried to do a internship for KDE with 6 students from one university that I have good relationship with, this experiment failed miserabily and I’ll try to do it again in the future but not in the same way that I did. The students did a few things, but at turtle paces, two quit in the first week, two did nothing for two months, while I was trying and trying to help them, they didn’t want help ( or work… ), that’s a real problem with “Free Software Groups” on universities that I’ll talk more in other post. But seriously, if you don’t want to work, don’t ask for a job. The code that they did will eventually end on KDE 4.11 ( since 4.10 passed by and they didn’t delivered. -.-’ )
This is my small resume for KDE in 2012, I hope 2013 is a better year
Call for arms: QtMof/QtUml December 11, 2012
Posted by Sandro Andrade in planetkde-sandroandrade, planetqt-sandroandrade.3 comments
Hi planet,
As roughly mentioned in a previous post, in last two months I’ve been working on a Qt5-based implementation of OMG’s MOF (Meta Object Facility) and UML (Unified Modeling Language) specifications. For those of you who are more familiar with a user-perspective view of UML, it’s worth mention that UML (and your defining metalanguage, MOF) provides a powerful infrastructure which enables, for example, programmatic handling of models, early analysis of architectural models, effective middleware/framework-driven artifact generation, use of deployable models in run-time, and so on. A considerable amount of work has been done towards the development of high-quality tools which leverage the use of models in software development processes. Efforts like the Eclipse Modeling Framework have been setting the stage for a number of plugins, environments, or even tailored Eclipse versions (Eclipse Modeling Project), which rely on modeling features to provide a complete toolset for model-driven engineering. QtMof/QtUml aim at bringing such features to the Qt5 world.
QtMof/QtUml rationale has been driven by the following desired properties:
- We should support automatic code generation as much as possible. Only 8.17% of UML 2.4.1 metamodel properties are declared as ‘derived’ (and not derived unions), which prevent automatic code generation. For those properties, the specification provide the guidelines for implementation but maybe some of them could be automatically derived from their OCL specifications. QtMof/QtUml already provides a mapping from UML to Qt5 by first generating a more Qt-ish representation of a UML model (XQuery-based xmi to qtxmi conversion) and then generating source code from a couple of well-design templates. Such infrastructure has successfully been used to generate the initial skeletons of QtMof/QtUml and can also be used to convert user-defined UML models into Qt5 source code. As a consequence, we hopefully end up with a faithful implementation of OMG’s standardized metamodels.
- We should provide a metamodel-agnostic tool for editing, analysing, and converting any MOF-based model. By having no compile-time commitments with any specific MOF-based metamodel, such tool would be also able to handle other MOF-based metamodels (such as CWM) or even user-defined meta-models.
- QtMof/QtUml should provide a powerful modeling notation for early analysis of MOF-based models. A number of preset scripts for checking well-formed rules should be available and specific scripts may be defined by the user. OCL is a potential candidate as script language, but XQuery or even QtScript can also be considered. That would make possible, for example, analysis of conformance to architectural styles/patterns, continuously integrated models, and so on.
- A flexible mechanism for mapping of models into middleware/framework-specific artifacts should also be provided. A uml2qt mapping is already in place, but new ones should be easily defined.
Getting right down to the business instead of talking on abstractions that’s what a QtUml application currently looks like:
QWrappedObjectPointer<QModel> model = new QModel;
model->setName("MyModel");
QWrappedObjectPointer<QPackage> package = new QPackage;
package->setName("Package1");
QWrappedObjectPointer<QPrimitiveType> primitiveType = new QPrimitiveType;
primitiveType->setName("String");
QWrappedObjectPointer<QEnumeration> enumeration = new QEnumeration;
enumeration->setName("DirectionKind");
QWrappedObjectPointer<QEnumerationLiteral> directionIn = new QEnumerationLiteral;
directionIn->setName("DirectionIn");
enumeration->addOwnedLiteral(directionIn);
QWrappedObjectPointer<QClass> class_ = new QClass;
class_->setName("Student");
class_->setAbstract(false);
package->addOwnedType(enumeration);
package->addOwnedType(class_);
model->addPackagedElement(package);
model->addOwnedType(primitiveType);
// query model or perform 'well-formed/sanity/architectural conformance' checks
delete model.data();
Let’s shed some light on the code above. First of all, UML 2.4.1 metamodel specifies a set of 242 metaclasses (193 out of those are concrete metaclasses) with a couple of dreaded diamonds. In order to overcome the inherent QObject disabilities to cope with virtual inheritance, QtMof/QtUml provides (and relies on) the QtWrappedObjects library: an easy-to-use Qt5-based implementation of “smart delegators” and “delegation-based multiple inheritance”. All behind-the-scene hard work is handled by a new smart pointer (QWrappedObjectPointer) and a new casting operator (qwrapperobject_cast). Secondly, model elements can easily be imported from other (meta)models instead of explicitly instantiating them by “new QPrimitiveType“, for example (use QElementImport/QPackageImport for that purpose). Thirdly, an element takes ownership of any (multi-valued or single-valued) UML property which was declared with “aggregate = composite”, so that a single “delete model.data()” do the whole work.
Even though not 100% implemented, UML Profiles and profile applications may currently be defined programmatically:
// Create a profile
QWrappedObjectPointer<QProfile> profile = new QProfile;
profile->setName("MyProfile");
// Add a stereotype to profile
QWrappedObjectPointer<QStereotype> stereotype = new QStereotype;
stereotype->setName("MyStereotype");
profile->addPackagedElement(stereotype);
// Show profile's owned stereotypes
QScopedPointer<QStereotypeList> ownedStereotypes (profile->ownedStereotypes());
qDebug() << "Owned stereotypes:";
foreach (QStereotype *ownedStereotype, *ownedStereotypes)
qDebug() << " " << ownedStereotype->name();
// Adding attribute to stereotype
QWrappedObjectPointer<QPrimitiveType> booleanPrimitiveType = new QPrimitiveType;
booleanPrimitiveType->setName("boolean");
QWrappedObjectPointer<QProperty> property = new QProperty;
property->setName("isTransient");
property->setType(booleanPrimitiveType);
stereotype->addOwnedAttribute(property);
The following lines apply an existing UML profile to a package:
// Create UML meta-model element import
QWrappedObjectPointer<QElementImport> elementImport = new QElementImport;
elementImport->setImportedElement(umlModel->packagedElements()->toList().first());
// Add meta-class reference to profile
profile->addMetaclassReference(elementImport);
profile->addOwnedType(booleanPrimitiveType);
// Create extension
QWrappedObjectPointer<QExtension> extension = new QExtension;
extension->setName("class_stereotype");
QWrappedObjectPointer<QProperty> stereotypeProperty = new QProperty;
stereotypeProperty->setName("base_class");
stereotypeProperty->setType(class_);
QWrappedObjectPointer<QExtensionEnd> extensionEnd = new QExtensionEnd;
extensionEnd->setName("extension_stereotype");
extensionEnd->setType(stereotype);
extension->addMemberEnd(stereotypeProperty);
extension->addMemberEnd(extensionEnd);
extension->setOwnedEnd(extensionEnd);
stereotype->addOwnedAttribute(stereotypeProperty);
Of course, a helper function or a QtScript can be created to provide a simpler API for creating and applying profiles. As for the editor, current status is still far from usable but it already works as a proof-of-concept for a metamodel-agnostic tool (it links only against QtWrappedObjects):
Potential future uses of QtMof/QtUml include: development of model-driven mechanisms in QtCreator/KDevelop, full UML2.4.1/2.5 support in Umbrello, effective Qt code generation from UML models, and so on.
So, if you like modeling and would like to do some code reviewing and/or help hacking QtMof/QtUml you are quite welcome . You can grab QtMof/QtUml source code at Qt Playground Repository. Alternatively, if you run openSUSE, there is an OBS repository which provides QtMof/QtUml binaries. In order to use them you must include Qt5 and QtMof/QtUml repositories and install the required packages. The libQtMof-devel package provide the examples for profiles and the current editor:
zypper ar -f http://download.opensuse.org/repositories/KDE:/Qt50/openSUSE_12.2 openSUSE-12.2-Qt5 zypper ar -f http://download.opensuse.org/repositories/home:sandroandrade/openSUSE_12.2 openSUSE-12.2-QtMof zypper ref zypper in libQtUml-devel
See you …
QObject, multiple inheritance, and smart delegators October 29, 2012
Posted by Sandro Andrade in planetqt-sandroandrade.8 comments
Hi there,
In last weeks I’ve been working on a Qt-based implementation of OMG’s UML/MOF specifications (more about that coming soon). The normative XMI files provide the full UML meta-model, featuring a number of multiple inheritances and dreaded diamonds. So, you can expect some hard times because of QObject disabilities for handling virtual inheritance and templates (no mix-ins ? no traits ?). Furthermore, a design and analysis tool for handling MOF-based models is also been developed and, as such, should be highly reflective in order to not be tied to any specific meta-model. Qt’s property system could easily do the trick, but keeping reading .
Since a number of classes in UML meta-model are abstract, a possible solution to overcome QObject’s multiple inheritance issues would be to postpone QObject inheritance to lowest possible class in hierarchy. Also cross you fingers for not having a concrete class inheriting from two (or more) other concrete classes (actually, in UML this only occurs in ‘AssociationClass’). Current implementation is somehow akin to:
QElement is an “abstract” (protected constructor) class:
class Q_UML_EXPORT QElement
{
public:
virtual ~QElement();
const QSet<QElement *> *ownedElements() const;
...
protected:
explicit QElement();
};
QNamedElement is also an “abstract” (protected constructor) class:
class Q_UML_EXPORT QNamedElement : public virtual QElement
{
public:
virtual ~QNamedElement();
QString name() const;
void setName(QString name);
QtUml::VisibilityKind visibility() const;
void setVisibility(QtUml::VisibilityKind visibility);
QString qualifiedName() const;1 // read-only
QNamespace *namespace_() const;
...
protected:
explicit QNamedElement();
};
QPackage is a concrete class:
class Q_UML_EXPORT QPackage : public QObject, public QNamespace, public QPackageableElement, public QTemplateableElement // dreaded diamonds here
{
Q_OBJECT
// From QElement
Q_PROPERTY(const QSet<QElement *> * ownedElements READ ownedElements)
// From QNamedElement
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(QString qualifiedName READ qualifiedName)
Q_PROPERTY(QElement * namespace_ READ namespace_)
public:
explicit QPackage(QObject *parent = 0);
virtual ~QPackage();
};
That’s fine, even though generated documentation becomes somehow weird because of property accessors being implemented in base classes.
Issues arise, however, when implementing the analysis tool. It would be great if each property could be dynamically verified if it is a QNamedElement and its name would be exhibited in a property editor. Something like:
...
int propertyCount = currentElement->metaObject()->propertyCount();
for (int i = 0; i < propertyCount; ++i) {
QMetaProperty property = element->metaObject()->property(i);
QString typeName = property.typeName();
if (typeName.endsWith('*') and !typeName.contains(QRegularExpression ("QSet|QList"))) {
if (QtUml::QNamedElement *namedElement = property.read(element).value<QtUml::QElement *>()) {
tableItem->setText(namedElement->name());
}
}
...
The sad thing is: in Qt4, values can be extracted from QVariant’s only by using the same type used when constructing the QVariant. Qt5 introduces a nifty feature where you can safely extract a QObject * from any QVariant built from a QObjectDerived *. That would easily solve the issue above provided that QNamedElement would inherit from QObject .
So, it seems the solution requires inheriting from QObject early in hierarchy (QElement) and get rid of multiple QObject inheritance by using delegation. In addition, accessing ‘sub-objects due to inheritance’ and ‘sub-objects due to delegation’ by using a common API would be a plus. That’s what I came up with:
class MyQObject : public QObject
{
Q_OBJECT
public:
explicit MyQObject(QObject *parent = 0);
virtual ~MyQObject();
template <class T> friend inline T myqobject_cast(MyQObject *object);
protected:
QSet<MyQObject *> _subObjects;
};
template <class T>
inline T myqobject_cast(MyQObject *base)
{
if (dynamic_cast<T>(base))
return dynamic_cast<T>(base);
foreach(MyQObject *myqobject, base->_subObjects) {
T returnValue = myqobject_cast<T>(myqobject);
if (returnValue != T())
return returnValue;
}
return dynamic_cast<T>(base); // not found
}
A first MyQObject-derived class:
class Derived1 : public MyQObject
{
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName)
public:
explicit Derived1(QObject *parent = 0);
QString name() const;
void setName(QString name);
private:
QString _name;
};
A second MyQObject-derived class (Derived2) would be defined similarly.
A class “multiple inheriting” indirectly from MyQObject would be:
class Join : public MyQObject // no inheritance, no dreaded diamonds, 'smart delegation' instead
{
Q_OBJECT
public:
explicit Join(QObject *parent = 0);
~Join();
private:
Derived2 *_derived2;
Derived1 *_derived1;
};
Join::Join(QObject *parent) :
MyQObject(parent), _derived2(new Derived2), _derived1(new Derived1)
{
_subObjects.insert(_derived11);
_subObjects.insert(_derived2);
}
Join::~Join()
{
delete _derived2;
delete _derived1;
}
That done, how a client would look like ?
Join *join = new Join;
if (myqobject_cast<MyQObject *>(join))
qDebug() << "myqobject_cast<MyQObject *>(join) ok";
if (myqobject_cast<Derived1 *>(join))
qDebug() << "myqobject_cast<Derived1 *>(join) ok";
if (myqobject_cast<Derived2 *>(join))
qDebug() << "myqobject_cast<Derived2 *>(join) ok";
if (!myqobject_cast<Unrelated *>(join))
qDebug() << "myqobject_cast<Unrelated *>(join) fail";
That would remove the burden of creating tons of stub methods (if aggregated object is deeply lower in hierarchy) and one more level of indirection (how to simulate virtual methods ?). Yes, sub-objects representing the tip of dreaded diamonds would be duplicated but myqobject_cast would return always the same sub-object.
I’m wondering how much of this could be automated by moc so that we could have something like:
class Join : public MyQObject, wraps Derived1, wraps Derived2
{
Q_OBJECT
public:
explicit Join(QObject *parent = 0);
~Join();
};
And that’s all, all hard work behind the scenes would be generated by moc Only a little change in perspective when using such object would be needed (think always in terms of myqobject_cast’s).
So, too much engineering ? Any alternative solution ? Comments ?
See you !
Help the Creativity of Children around the world October 16, 2012
Posted by tumaix in planetkde-tomazcanabrava.add a comment
People, this is a very serious pledge campaign, I didn’t wrote but actually copied the text to put on planet-kde, thus, making it more spread around the globe.:
Original text from the pledge:
Some might remember a little campaign I started in February. Its time to do it again, bit why now? The answer is very simple LibreGraphicsMeeting will be next year a little bit nearly a month earlier. Additional to that some of the receiver of the campaign need a visa for going to Spain, where the next LibrGraphicsMeeting will be. They have to get the visa 6weeks before they enter the country so that would be end of February. And additional to that the have to show the tickets for the flights especially the back flight and the reservation of a hotel, pension or something similar. So we need the most of the money until that date or they can not go to the event.
This time there are three persons, I like to collecting for:
Gustavo Gonzalez, who is the author of Tupi – Open 2D Magic, a program for doing traditional 2D animations. If you take a look there are really not a lot of alternatives in this area in the FLOSS world, the only one would be SynfigStudio but that is to complicated. Tupi is easier to handle and to learn. In the last months Tupi made also a lot of progress, we tried to package it but it was totally wrong build dependencies like ffmpeg made it not possible to include it into Fedora. So Gustavo removed all that dependencies and structured it new, so that you can use it without ffmpeg and export the animations as ogv. But ffmpeg support is still available as plugin. There was also some other major improvements like a storyboard. I am sure when it is packaged a lot of people will like Tupi, the Design Team cant wait for it.
Gustavo tried already this year to go to the LibreGraphicsMeeting in Vienna but it did not happen because he had no money for doing it. He like to present Tupi at that event and I am very sure that is useful for him and the development of Tupi. So lets help him.
Second person is Onyeibo Oku from Nigeria. Onyeibo is since a long time member of the Fedora Design team, but he is also active as Ambassador in Africa. Onyeibo sketches really good and he is good with Blender. For him is important to meet some other people from the design team and he wishes also to give a talk at LibreGraphicsMeeting.
Last candidate I might know, its Tatica again. She was, thanks to a lot of donations, at the last LibreGraphicsMeeting and learned a lot there and like to go again.
So what will it cost? There are the flights for Tatica around 1200€/1550 US$, for Gustav around 1000€/1290US$ and for Onyeibo around 800€/1030US$. For Tatica last time we calculated 70€/90US$ for hotel. But we didn’t need so much because Tatica slept in an apartment which became much cheaper. I did some research and want to rent an apartment for them again, that will cost another 900€/1160US$. So the whole makes 3870€/5030US$
Because Pledgie and Paypal get each 3% of the sum, the sum would be 4080€/5300US$. Additional to that Paypal gets a small sum for each transfer, but that is hard to calculate. I calculated 80€/100US$ for that.
So what will happen if we get not the whole sum? When we reach the sum for the flight for Gustav, he will get it first, after that Onyeibo and last Tatica as she was already at LibreGraphicsMeeting. But we need the sum for the flights in February otherwise we get no visa for Gustav and Onyeibo. But hopefully we get the sum but that’s up on you.
All KDE-Edu Apps with KActivities on 4.10 October 16, 2012
Posted by tumaix in planetkde-tomazcanabrava.4 comments
Ronaldo Fernandes, a Student from faculdades ruy barbosa that is doing it’s first internship for KDE is doing an awesome work porting all KDE-Edu apps to KActivities for inclusion on KDE 4.10, he’s having a lot of help from me, and I’m having a lot of help from Ivan about the KActivities system.
Apps that are already KActivity enabled ( in our branch, I’m reviewing everything before sending to reviewboard the diffs ) are Kig, KAlgebra, Cantor, KTouch, KHangMan and KTurtle.
KDE-Edu and KDE-Utils fully Activity-Enabled for 4.10? October 1, 2012
Posted by tumaix in planetkde-tomazcanabrava, uncategorized.2 comments
the ‘Intern me on KDE’ program is starting to give it’s fruits.
two of my the students are now porting evey-app (where applicable ) of kde-edu and kde-utils to use the KActivities plugin, if installed.
Kudos to them.
Intern me on KDE September 5, 2012
Posted by tumaix in planetkde-tomazcanabrava.2 comments
For the first time KDE in brazil is trying something that can change the way how we interact with universities and students, boosting opensource development as a whole. I’s a common thing to have big companies like MicroSoft and IBM with partnerships with universities, but what about OpenSource and LibreSoftware? I know that there are loads and loads of GNU-OSS-Free groups at colleges and all that jazz… but that eint what I’m talking about baby. I’m talking about something harder, better, faster, stronger. what about a *REAL* partnership between one of the biggest ( in terms of lines of code, users and programmers ) open source projects of all times, you know, the one that started to be the gift from a loving guy to his girlfriend. ( I don’t know about you guys, but I actually am proud to work in a project that started as a concern to make the world a better place to someone I like )
KDE and the Faculdades Ruy Barbosa are joining forces this winter ( for the winter is not comming in the south, and while winter may be a slow season up north, with 6m of snow in Oslo, it’s pretty damn hot down here. ) Six students will work 20h per week, for six months for KDE. They asked me how they could help a project, I asked them if they wanted to be interns, and they loved the idea. Right now it’s the beginning. They started formally at Setp 1st, are studing the code and all that jazz.
But what are they going to do? What are their premisses? who is behind this? What is the catch?
Six students, Two teams. In an ideal world, I would put them in six teams of one and each one could take care of himself, but the real world eint no plain, so they will work together, this way things can go better.
RainGuards – The Umbrello Helpers – This team is focused on helping umbrello, making it a good and modern UML modelling tool. their initial task is to move umbrello from SVN to Git, they are already studing svn, git, svn2git and the old umbrello rulesset. After this, they will fix bugs, clean the code, do the UML modelling of Umbrello’s code with umbrelo itself to stress test the application. A good app must be able to dogfood itself.
Activators – the KDE Activities Helpers – This team is focused on helping KDE Activities as a whole, porting applications to use the activities, helping the activities daemon, the library and helping Ivan to sing Bohemian Raphsody. Their initial task is to Build everything – and that’s eint no easy task for them, because the Activities are splitted in several subprojects ( library, daemon, plasma-activity-chooser, applications that uses activities ) . Their first task is to sort the Krunner – find-files plugin by rating, and while this seems more a Nepomuk thingy than an Activity thingy, all is related.
Good Luck for them, and for me, because if this works out, more universities will come next year. 
Doe para o KDE-Edu sprint em Randa – 2012 August 15, 2012
Posted by tumaix in qla-tomazcanabrava.add a comment
