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:

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.

Demo video here

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):
  • qt5-5.0.0-3-x86_64.pkg.tar.xz
  • qtwrappedobjects5-0.89-0-x86_64.pkg.tar.xz
  • qtmof5-0.89-0-x86_64.pkg.tar.xz
  • qtuml5-0.89-0-x86_64.pkg.tar.xz
  • qtumleditor-0.89-0-x86_64.pkg.tar.xz
• 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 …

• 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

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 …

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 !

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.

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.

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.

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.

FISL13 is over and it’s always hard to say goodbye to dear friends who make up the KDE Brazil. But certainly the one we’ll miss most about is our beloved Konqi who invaded FISL this year. He’s right now long hibernating at Henrique & Camila’s place (thank you guys, you’re amazing) and recharging his energies for Latinoware 2012, to take place in late October. We had this year Sebas joining us for nice KDE conversations, some beers, and spreading the use of Plasma Active. We’ve got some new people interesting in artwork (we have some amazing screencasts on Krita in action, where are they Tomaz ?) and we managed to have some t-shirts and konqi pins at KDE booth.

Last Saturday we had the release party for 4.9 deliverables here in Salvador – Bahia. Ekaty guys were there trying to justify the reason for still not having 4.9 in their repos and Luis always elaborating his ideas

See you …

1 – By organizing a release party ( and rejoice)
2 – By going to a release party ( and rejoice )
3 – By convencing people to go to a release party ( and rejoice )
4 – By being a photographer in the middle of a release party and taking
pics for us ( and rejoice. )
5 – By dressing yourself like Konqui, walking around and hugging
people ( and rejoice )

ps.if you are a Photographer, you will also stop a bit and take a look at the amazing DigiKam.
But then, you may ask “How do I organize a Release Party?” not that complicated, there are some rules that should be followed, always.

1 – It’s a Party, so you should do Party things.
2 – It’s a Party, so you shouldn’t do unparty things.
3 – Invite your friends \o/
4 – Invite famous people \o/
5 – HAVE FUN!
6 – Register the party at our Wiki, so everyone knows what’s happening.

But then you may ask “How can I go to a release party?”
not that complicated, there are some rules that should be follwed, always.

1 – check our wiki, all parties should be there. if there’s none near where you live, create one and blog about it.
2 – Check the time, Check the place, Check your geek stuff, Go.
3 – Invite your friends \o/
4 – Invite famous people \o/
5 – HAVE FUN!
6 – Don’t forget to blog about how was the party. \o/
But then you may ask “How can I convence people to go to a release party?” not that complicated, there are some rules that should be followed, always.

1 – if they don’t like computers, Trick Them.
2 – If they work as teachers or professors, tell them how cool the
KDE-Edu guys are.
3 – if they like sports, run to the party, they sure will follow.
4 – if they like arts, Neil Gaiman’s poetry about tech.
5 – If they think they are too cool for a release party, invite cooler
people \o/
6 – if they are Photographers, tell them that a bianual event will
happen, and you need good pics. =D
But then you may ask “How can I be a photographer in the middle of a release party”? not that complicated, there are some rules that should be followed, always.
1 – You just happen to be there.
2 – You got invited to be there.
3 – You got tricked to be there
4 – You are there because you date someone there.
5 – You love Digikam and the kipi-plugins, and wanna rejoice \o/

But then you may ask “How can I dress myself like konqui and hug people”?
Don’t know, but I sure wanna some pictures if you made it. \o/

Por que voce gastaria alguns dolares em um aparelho que é um pouco mais que umsmartphone (com uma tela maior mas sem o telefone) ?

Apesar do sucesso dos iPads da Apple essa é uma questão que parece desafiar a maioria dos vendedores de hardware e software. O MeeGo lutou para construir uma interface de usuário para tablets mas não conseguiu mais que um pré-lançamento. Apresentou algumas funcionalidades simples, tais como assistir vídeos, tocar música ou navegar na web, realmente não mais do que um telefone moderno com uma tela maior poderia fazer. Mesmo o iPad, um reconhecido sucesso, é pouco mais do que um iPhone maior. O seu conjunto de aplicações tem sido amplamente copiado pelos tablets baseados em Android que surgiram no mercado até o momento.

Mas para que servem os tablets ?

Um tablet em uso (ou não utilizado em uma de suas gavetas) é um verdadeiro computador. Ele pode fazer mais do que simplesmente navegar na web e assistir vídeos ? Marco Martin, conhecido hacker KDE e colaborador da basysKom pensa assim: “o fato que pessoas baixam e usam várias aplicações mostra que existe esse desejo de fazer algo mais”. Ele se incomoda com o fato que “a maioria das aplicações para dispositivos móveis parecem estar desconectadas uma das outras”. Marco acredita que é este o ponto onde o Plasma Active - interface para usuário desenvolvida pelo KDE e o conjunto de aplicações para dispositivos móveis touchscreen - pode atacar e disponibilizar uma brilhante solução.

Figura 1. O Plasma Active vem com uma seleção de aplicações, algumas mais prontas para touchscreen do que outras

O Plasma Active traz uma nova abordagem para dispositivos touchscreen e tenta oferecer mais do que um conjunto de aplicativos para as tarefas mais simples. Mais que um desktopou mesmo um notebook, um aparelho touchscreen é fácil de ser transportado e utilizado em diferentes contextos e para diferentes fins. O Plasma Active faz uso das activities do KDE, algo que tem confundido os usuários do ambiente desktop (veja activities - uma solução procurando por um problema ?), mas, os desenvolvedores acreditam, que faz sentido nostablets.

Aaron Seigo – membro-fundador do Plasma Active e um dos principais desenvolvedores por trás da família de interfaces para usuário KDE Plasma – celebra as activities como um grande avanço, dizendo que “muitos consideram que a habilidade de organizar informações e aplicações entre diferentes activities aumenta significativamente o valor do dispositivos na vida deles”. Ele usa um exemplo pessoal: “enquanto eu estava de férias, utilizei as activities para manter o controle dos meus roteiros e planos, de algumas tarefas do trabalho e para manter-me atualizado de tudo na volta para casa. Eu tenho algunstablets Android e em nenhum deles teria sido tão útil.”

Activities - uma solução procurando por um problema ?

Desde 2008 o KDE tem investido no conceito de activities com resultados divergentes. Muitos usuários não têm certeza da diferença entre activities - projetada para permitir a divisão de diferentes tipos de tarefas – e desktops virtuais – utilizados por muitas pessoas para também dividir diferentes tipos de tarefas.

A idéia é que, embora os desktops virtuais ofereçam espaço extra e alguma forma de agrupamento (por exemplo, você pode ter diferentes áreas de trabalho para e-mail, web, trabalhos numéricos e trabalhos gráficos), as activities disponibilizam interfaces específicas para tarefas diferentes em diferentes momentos.

Imagine que você é um estudante universitário. Você poderia usar os desktops virtuais conforme descrito acima: com e-mail em desktop virtual e anotações de aula em outro. Mas você pode usar as activities para definir agrupamentos para cada disciplina. Você teria uma calculadora na sua activity ”Aula de matemática”, uma tabela periódica na sua activity“Laboratório de química” e acesso rápido aos seus jogos na activity ”Tempo livre”. Com o mecanismo de troca rápida entre activities e as recomendações automática por activity, oPlasma Active leva este conceito mais longe, fazendo com que o tablet altere totalmente sua configuração de acordo com a mudança da activity. Dessa forma, você terá seu tabletconfigurado do jeito que você quer, para cada tarefa que você possa experimentar.

Figura 2. Você pode customizar cada activity com widgets específicos e alternar entre activities facilmente utilizando o Seletor de Activities.

Primeiras Impressões

Quando você inicia o Plasma Active pela primeira vez (veja Experimente o Plasma Active 2 para saber como usá-lo), você obtém o que parece ser um desktop KDE padrão. As principais diferenças são um painel no topo da tela e a ausência do menu convencional de aplicações. Duas pequenas abas parcialmente abertas em cada lado da tela também não são encontradas no espaço de trabalho padrão do KDE. Esses três itens fornecem o controle principal do Plasma Active. Arraste um pouco o painel de cima para baixo e você verá uma barra de tarefas sensível ao toque, com uma visualização dos aplicativos atualmente em execução e um botão para minimização destes aplicativos. Arraste um pouco mais abaixo e você verá um conjunto de ícones de aplicativos, não muito diferente das previstas no Android ou tablets da Apple, com uma caixa de pesquisa onde você pode rapidamente localizar o aplicativo desejado. Até agora, nada tão revolucionário.

Experimente o Plasma Active 2

O lançamento mais recente do Plasma Active é bem fácil de testar. Se você já tem um computador rodando Meego ou OpenSUSE você pode instalar os pacotes necessários. Entretanto, uma opção mais segura e conveniente é tentar um das live-images disponíveis – elas ainda podem ser utilizada para instalação caso você goste do Plasma Active. Live images baseadas no Meego são disponibilizadas pela basysKom, enquanto a open-slx fornece uma imagem baseada na distribuição Balsam Professional (derivada do OpenSUSE e mantida pela própria open-slx).

Você pode ainda tentar o Plasma Active em dispositivos ARM (por exemplo em tabletsAndroid) usando uma imagem construída com base no Mer – porte do MeeGo para arquiteturas ARM.

Detalhes sobre a instalação e opções de teste podem ser encontrados na wiki do KDE (http://community.KDE.org/Plasma/Active/Installation).

O desempenho das live-images depende do pendrive e do tablet sendo utilizados. Você pode instalar efetivamente o software para obter um melhor desempenho mas isso pode, é claro, sobrescrever o seu sistema operacional existente.

À medida em que o Plasma Active - e tablets em geral – se tornem mais conhecidos, é provável que muitas distribuições comecem a oferecer o Plasma Active como interface de usuário ou disponibilizem distribuições especialmente otimizadas para o Plasma Active.

Como Aaron Seigo notou: “uma solução somente importa se as pessoas podem realmente utilizá-la”. Você poderá encontrar algum dia dispositivos com Plasma Active à venda, a equipe do Plasma Active está “trabalhando muito para tornar isto uma realidade em um futuro próximo”.

Se adaptando a diferentes tarefas

As duas abas dos lados da tela são características únicas do Plasma Active. A aba na direita quando arrastada revela o seletor de activities, onde cada activity é representada por uma imagem. Algumas activities são pré-definidas, tais como “Introdução” (fornece alguma informação sobre como começar), “Plano de Férias” (exemplo de activity para uma atividade específica) e “Minha Primeira Activity” (que o convida a fazer a sua própriaactivity). Você pode remover, configurar ou adicionar activities usando ícones que estão visiveis no seletor de activities.

Figura 3. Você pode ter uma activity para cada tarefa que você precisa e deseja fazer.

Selecionar uma activity modifica o papel de parede e os widgets do desktop para aqueles associados com a activity selecionada. Escolha a activity de planejamento de férias e você verá o papel de parede associado, terá o widget KDE para previsão do tempo e osbookmarks para o OpenStreetMap, Wikitravel e serviços ferroviário em seu desktop. Você pode abrir um navegador e começar a fazer as suas reservas de férias mas se o seu filho (ou você) tem uma repentina vontade irresistível de jogar Solitaire, você pode simplesmente mudar para uma activity criada para jogos. Se você verificar a barra de tarefas (puxando para baixo o painel do topo) você vai ver que ele só exibe as aplicações da activity atual. Portanto, suas reservas de férias estão a salvo de pequenos dedos acidentalmente fechando o navegador ou atualizando as reservas para viagens transatlânticas de primeira classe. Uma vez que seu filho (ou você) tenha terminado de jogar, você pode usar o seletor de activities para voltar a reservar as suas férias rapidamente.

Ficando esperto com Nepomuk

A aba do lado esquerdo da tela exibe as recomendações do Plasma Active: links para arquivos, widgets e contatos que podem ser relevantes para a atividade atual. Tudo isso é baseado no Nepomuk: tecnologia de armazenamento semântico do KDE que cria links entre itens baseado nos seus contextos de uso. Marco explica que isso permite que “as informações armazenadas no dispositivo sejam mantidas em um local central, permitindo que sejam tratadas de maneira uniforme e exibidas de forma coerente, independentemente se é um arquivo, um contato, um bookmark ou informações sobre um local, ligando-as através de informações semânticas”. O que isto significa na prática é que as recomendações são mais do que uma lista de arquivos usados recentemente ou mais acessados, sugerindo documentos que são frequentemente usados em conjunto com aqueles atualmente abertos ou usados frequentemente na mesma activity (as recomendações são específicas a cada activity). Enquanto eu escrevia este artigo o sistema me sugeriu alguns itens irrelevantes mas rapidamente aprendeu a sugerir imagens que eu tinha coletado e sugeriu acrescentar as “Diretrizes para autores do Linux Journal” e o “Plasma Active Wiki Pages” aos meus favoritos. A idéia é que o sistema aprenda com o seu usuário e torne-se cada vez mais útil com o passar do tempo. Com base na minha experiência, o Plasma Active ganha a minha aprovação mas com cautela.

Figure 4. O Plasma Active disponibiliza recomendações de arquivos e ações relevantes à activity atualmente em execução.

O Nepomuk, desde que foi introduzido pela primeira vez no KDE em 2008, tem sido alvo de muitas queixas sobre o uso de recursos, algo que é certamente motivo de preocupação ainda mais em um dispositivo portátil de baixo consumo de energia. Marco, no entanto, aponta que “em um dispositivo móvel a quantidade de dados armazenados é muito pequena se comparado a um desktop, e as medições mostraram que o uso da memória permanece muito pequeno devido ao número limitado de itens”. Além disso, ao utilizar um armazenamento central “evita-se a necessidade de desenvolver um armazenamento/indexação diferente para cada aplicação”. Aaron concorda: “os dispositivos alvo são atualmente todos na faixa de 600MHz a 1GHz de processamento com 256MB ou mais de memória RAM. Nesses dispositivos o Nepomuk funciona de modo aceitável”. Mesmo assim os desenvolvedores estão trabalhando em várias “otimizações e melhorias” e Aaron reconhece que há sempre a possibilidade de “desintalar o Nepomuk em alguns cenários menos favorecidos, em termos de hardware e interação com o usuário”. Eu não presenciei a tradicional lentidão que às vezes acompanha uma extensa indexação nos ambientes desktop.

As aplicações são o centro de tudo

A interface de usuário é elegante e bem planejada e, através das activities, oferece algo diferente da concorrência. No entanto, um computador é apenas tão bom quanto as aplicações disponíveis e, se deseja-se que o Plasma Active seja um sucesso, o KDE deve disponibilizar um conjunto convincente de aplicações touch-friendly.

Figura 5. As aplicações que já foram ajustadas para o uso com o Plasma Active, como o visualizador de imagens, funcionam bem.

Algumas variantes “Active” das aplicações do KDE já estão disponíveis. Estas incluem aquelas concebidas especificamente para o Plasma Active, tal como o navegador web e o visualizador de imagens, sendo que ambos bastante fáceis de usar. Algumas outras aplicações, tais como o media player Bangarang, sofreram modificações para se tornarem mais touch-friendly. Há versões Active para o conjunto de aplicações de groupware Kontact. Elas são fáceis de usar com touch-screen, mas suas interfaces são tão diferentes dos seus homólogos desktop que mesmo se você é um usuário experiente do Kontact, você vai descobrir que demora um pouco para se acostumar. O Calligra, parte da suite de produtividade do KDE, também está disponível na sua versão Active, porém com baixo desempenho no dispositivo que usei. Entretanto, a tecnologia de base do Calligra já vem sendo utilizada com sucesso nos visualizadores FreOffice dos telefones Nokia, por isso é provável que o desempenho melhore.

Algumas outras aplicações como o Dolphin (gerenciador de arquivos do KDE) não foram adaptadas para o Plasma Active. A mesma interface original é usada nas operações de abrir e salvar arquivos da maioria das aplicações, mas essas serão melhoradas nas próximas versões.

Uma das principais aplicações para tablets - o teclado na tela – funciona muito bem, com botões fáceis de usar e um layout sensato. Aparece quando necessário mas pode ser alternado de baixo para o topo da tela, se desejado.

Figura 6. O teclado na tela é fácil de usar e pode ser acultado quando necessário.

Compartilhar, Curtir, Conectar

Outro novo recurso do Plasma Active é a presença dos botões do painel superior: Compartilhar, Curtir e Conectar. Estes botões tornam mais fácil o compartilhamento imediato de conteúdo (tais como imagens) em redes sociais ou serviços de armazenamento on-line; “curtir” informações presentes em redes sociais ou localmente (por exemplo, fazendo obookmark de uma página), e conectar itens a outros como, por exemplo, associar um documento ou página web à activity atual de modo a sempre estarem prontamente disponíveis no futuro. Dessa forma, se você quiser ter acesso rápido a uma imagem, basta clicar no ícone “Conectar” para adicioná-la como um widget da área de trabalho da activityatual.

Figure 7. Você pode facilmente associar um arquivo ou página web à uma activity usando o botão Conectar (Connect).

Aberto para Negócios

O Plasma Active tem sido um projeto incomum dentro do KDE devido à forte participação de empresas desde a sua concepção. Entre estas a basysKom contratou desenvolvedores para trabalhar no Contour: a combinação de activities e recomendações centrais à experiência do usuário do Plasma Active. Marco afirma que “todo mundo da comunidade é convidado a participar e contribuir, assim como qualquer outro projeto KDE – as empresas são também membros da comunidade e estão ajudando em muitas tarefas (incluindo as menos divertidas, com o objetivo de alcançar o nível de qualidade necessário a um produto real)”. Estas empresas estão também tornando mais fácil experimentar o Plasma Active, através da disponibilização de live-images fornecidas pelo basysKom e open-slx (veja Experimente o Plasma Active 2).

Vida após o MeeGo

No passado, grande parte dos esforços do KDE no mundo mobile eram direcionados a dispositivos robustos baseados no MeeGo, particularmente aqueles criados pela Nokia. No entanto, a decisão da Nokia de usar o Windows como base para seus smartphones e o subsequente descarte do MeeGo pela Intel em favor da colaboração com a Samsung (Tizen) têm modificado este cenário. Estas notícias, entretanto, não preocupam tanto os desenvolvedores do KDE. Aaron aponta que “o Plasma Active não é dependende de qualquer sistema operacional e é altamente portável”. De fato, existem “live-images para o OpenSUSE, Meego e Mer”.

Dispositivos ARM rodando o Android são muito populares atualmente e o Plasma Activetambém tem alguns desses hardwares como alvo através de uma live-image específica para ARM baseada no projeto Mer. Mas e o Android em si ? Não é atualmente a alternativa mais atraente para Marco, que argumenta que “o Android, embora lançado com uma licença open-source, é fortemente controlado pelo Google e não deixa muito espaço para que uma comunidade de desenvolvedores cresça e contribua”. Ele, no entanto, reconhece que o Android “é de fato uma boa plataforma e não excluímos algum trabalho de integração com ela no futuro”.

Existe também a possibilidade de o Plasma Active ou tecnologias relacionadas vislumbrarem muito mais do que apenas tablets. Aaron observa que já “alguns estão sendo executadas em dispositivos handset“, mas que “a experiência de usuário atual foi projetada especificamente para tablets“. Ele planeja, no entanto, começar a trabalhar com “interfaces especificamente projetadas para outros form factors, tais como set-top boxes e handsets“. O elemento chave para isso é a forma com que o Plasma foi projetado: “o Plasma permite a contrução de múltiplas (e diversas) interfaces de usuário sem começar do zero. O Plasma Desktop, Plasma Netbook e agora o Plasma Active são exemplos reais deste benefício: todos eles são visivelmente bem diferentes mas compartilham quase todo o código.”

O futuro do Plasma Active

O Plasma Active é ainda um software recente. O Plasma Active 2 foi lançado pouco antes de este artigo ser escrito e é a versão discutida aqui. O Plasma Active 3 é esperado para o final de 2012 e “trará novos recursos e novas aplicações”, de acordo com Aaron. A partir de uma perspectiva puramente de usuário final, o número limitado de aplicações touch-friendly significa que o Plasma Active ainda não está pronto. No entanto, vale a pena experimentar e pode ser ainda mais atraente no seu terceiro lançamento ainda este ano. Ele já está mais elegante e completo do que qualquer um dos tablets MeeGo pré-lançados.

Há outras razões para se entusiasmar com o Plasma Active. Para Marco, a motivação para começar a trabalhar no Plasma Active teve “razões diferentes, ambas puramente tecnológicas e sociais”. As sociais são talvez melhor resumidas por Aaron: “atualmente há um foco excessivo em dispositivos criados somente para atender a proprietários de lojas de aplicativos e focam no consumo de novos dispositivos simplesmente pelo fato de serem uma novidade”, algo que ele acredita que tem “paralisado o progresso”.

Aaron vê um futuro diferente para o Plasma Active e aqueles que optam por contribuir ou usar o software: “deveríamos estar procurando uma forma de apoiar a vida das pessoas e torná-la melhor. Isso precisa ser feito de forma socialmente responsável, o que significa que software livre, bem como processos abertos, devem guiar o desenvolvimento. Este é o propósito do Plasma Active.”

Fontes

Plasma Active: http://plasma-active.org

Plasma Active Installation: http://community.KDE.org/Plasma/Active/Installation

Artigo Original (inglês): Linux Journal – Plasma Active – a New Approach to Tablet Computing

and I tougth, but what about those poor kde-promo guys that are on their feet all day long, talking to random and strange people in events like FISL and LatinoWare? What they have to cheer them up in times of trouble, when mother mary comes to them speaking words of wisdom? Just let it be? Nah.

Besides a deep love for the KDE-Community, for the software and for the fame, what else they got?

Well, not to worry anymore, for I made my hands dirty and sponsored a Konqui Costume to be used in almost everywere \o/

As you can see, it’s under construction.  I hope it gets ready for FISL 13, and it will be a fully featured and functional Konqui. The perfect cloth for a midnight in paris. Or a Samba party in Rio. Or swimming in a lake. It feets everything, it’s the universal, loved by all, mother and father of all konqui costumes.

TaimeTraquer is a TimeTracking application, based on gtimelog, it uses the same format, saves in the same place, so you can use both, or just one, in the same way that you use gtimelog.

It has some benefits over gtimelog, it also has some shortcommings, for instance, it doesn’t generate reports ( yet ) , but it’s easyer to use, because you don’t really need to open the app, focus the line editor, write the thingy.

you just need to write ‘tt’ on the KRunner ( the alt+f2 popup ) and magic will happen.

so, if you guys wanna try it out, it’s on my scratch space:

git.kde.org:scratch/tcanabrava/taimetraquer

remember to adjust KDEDIRS and to run kbuildsyscoca4, and reestart krunner ( kquitapp krunner && krunner ) before trying to use it.

Manual: Write ‘tt arrived’ to mark that you just arrived, and ‘tt otherStuff: just did stuff’ to mark what you just finished.

I do accept ideas for improving the implementation.

So, this time instead of doing a plasmoid, I’m doing a fully-compatible GTimeTracker KRunner app, it’s already fully functional, and I will send it to KDE Infrastructure as soon as I remmeber my ssh key -.-’.

I would like to thank Aaron Seigo, Chani and all plasma devs for the plugin system in krunner, it helped me a lot those days =)

Hi there,

Yes, LaKademy is over. They were days of hard work, meeting old and new friends, and having much fun while realizing how far those crazy guy’s imagination can go. I’d say it was a great summit and, when compared to first (and only one so far) Akademy-BR carried out in 2010, it’s a clear evidence we are getting there in the effort of building a strong and mature KDE community in Latin America. Henrique and Camila managed to book a lovely hostel in Porto Alegre and, even though I usually don’t get used to traditional food in Rio Grande do Sul, we were all nicely accommodated through these days. Sorry for haven’t posted before, I’m rather taking an “all-in-one” approach to report LaKademy outcomes.

LaKademy brought together 19 participants, including developers, translators, designers, and promo people. Trying to keep this post simple and concise, I’ll briefly enumerate major LaKademy outcomes related to artwork and localization, promo, and developing. In particular, my own developing outcomes are presented later.

Artwork and Localization Outcomes

It seems that Tomaz has unintentionally taken over the task of bringing new designers for KDE here in Brazil. The difficulty arises from the proprietary background designers usually possess and then excuses of reduced productivity are a major obstacle to migrate to open source tools. At LaKademy, Tomaz, Manu, and Fabiana discussed current artwork needs of KDE and had a conference call with Nuno, trying to clarify tool differences and line up goals. Actually, I still notice that designers are maybe the most difficult people to be aware of real underpinnings of free software contribution and we haven’t found the means to provide that to them yet. Rocs’ “weird lemon add node icon” is still there but hopefully some artwork fresh blood will help us to get rid of it.

Aracele, Diogo, Camila, and Henrique have been working hard :) in userbase and techbase localization. Techbase pt_BR localization coverage run from 6% to 30% by the end of LaKademy.

Promo Outcomes

The promo meeting at LaKademy took an entire morning with discussion topics like: lessons learned from previous promo efforts, KDE Brazil/LatAm web presence, upcoming FLOSS conferences, and promo material manufacturing. Expected short-term accomplishments include:

• KDE Brazil|Argentina|Peru ?|LatAm web site (re)design. We aren’t sure about the need for a KDE LatAm web site (that discussion is going to continue on kde-latam mailing list) but we all agree on a re-design of KDE Brazil website. I’ve just noticed that ar.kde.org redirects to a drupal-based website.
• KDE LatAm Webcasts. Chicão has already pushed some tutoriais about making video tutorials about KDE.
• “KDE Masters of Latin-America” (TM by Guilhermo Amaral) Podcasts
• Git repository for standard KDE kick-ass presentations (btw, how to create translatable LibreOffice documents ?)
• “Myths and Facts about KDE Technology” marketing campaign. The intended audience is those people who still have a KDE Plasma 4.0-4.2 conceiving and haven’t given it another try since then. Our participation in FLISOL, while at LaKademy, have confirmed that we need such campaign.
• Upcoming FLOSS conferences in Latin-America. A bunch of FLOSS conferences (Congresso da SBC/ENECOMP, FISL, Latinoware, GNUGraph, FSLDC, Hack’nRio, LinuxWeek(Peru), CaFeCon(Argentina), Software Freedom Day, Campus Party Peru, Campus Party Pernambuco) are going to happen and we need to articulate the KDE participation in those.
  • In particular, we considered that a “KDE Day” (in a format similar to FLISOL) taking place simultaneously in various Latin-America cities might be a fruitful marketing strategy, even though with minimal technical outcomes. Initial tentative date is 27th October, just one week after Latinoware (so that we could do some announcement there).
• Quite minimal, enduser-oriented KDE portal. Something like descubra.kde.org (discover.kde.org) would provide, with a minimal simplified mapsite, the general reasons to use KDE and how to get it running in an easy way. That would support a KDE promotion effort in those fields aren’t related to technology at all. We see a huge potential of KDE adoption in Latin America and maybe we are driven our efforts to a most restricted audience.

Developing Outcomes

A number of developers were in LaKademy making improvements in projects like Rocs, KMyMoney, Plasma Network Management, Cantor, Digikam, KDevelop, Amarok, Plasma Active, and Telepathy. We had roughly 18 bugs fixed in Rocs by Tomaz and Wagner, Vitor has been working on a kipi plugin, Ronny worked in ports of KDE Games to Qt Quick, Arthur and Lamarque managed to have a working pilot for a new QML-based Plasma Network Management (part of his GSoC project), Filipe has started a new Python backend for Cantor, Alvaro has fixed bugs in KMyMoney, Lucas is finding his way towards a GSoC project in Amarok, Luis has made some improvements in Spinet architecture and GUI, and Chicao (who unfortunately couldn’t attend LaKademy) is already working on his GSoC project in Krita. As for myself, I dedicate my LaKademy attendance also to have hierarchical edge bundles working in KDevelop. Keep reading …

Compound Graphs and Hierarchical Edge Bundles

Information/Software Visualization techniques has been providing increasingly powerful paradigms for understanding huge amount of data and that certainly would help to support more effectively software design and evolution activities. In particular, a number of techniques for visualizing tree structures have been proposed in last years:

An even more interesting scenario is the use of compound graphs to represent adjacency relationships (between tree’s leaves) along with hierarchical relationships already provided by trees. One should consider, for example, professors hierarchically grouped by departments and also having adjacency relationships when co-authoring a paper or co-mentoring a student. In a software development project, that would easily be represented by hierarchically grouped artifact containments (like namespaces, classes, functions, etc) and some dependency relationship (for example, uses) between classes or functions. The use of arrows to represent adjacency relationship directions would produce more visual clutter so edges are drawn from source (green) to target (red).

A common issue when visualizing such compound structures is the visual clutter you rapidly come up even for small sized graphs. A pretty interesting paper by Danny Holten, “Hierarchical Edge Bundles: Visualization of Adjacency Relations in Hierarchical Data”, proposes a strategy for compound graph visualization which reduces visual clutter while still highligths implicit adjacencies in higher level containments:

So at the end of LaKademy I wanted to have at least the radial layout with edge bundles running in KDevelop.

libgraphicstreeview

Hierarchical edge bundles in mirrored radial tree view (rightmost view above) were implemented in a separated library so that other applications could use it for visualizing tree data other than KDevelop projects. Classes were designed to easily support the future inclusion of new tree layouts while reusing the edge bundle generation part. The RadialGraphicsTreeView class (first implementation of IGraphicsCompoundTreeView) works with any tree-based Qt model (representing the hierarchical model) and accepts a second table-based Qt model representing the adjacency relations. Any tree-based and table-based Qt models representing hierarchical and adjacency relations, respectively, should be correctly visualized by libgraphicstreeview. A number of parameters (node radius, inter level spacing, inter span spacing, bundling strength, mirroring radius increment, etc) can be used to tailor the visualization for specific purposes.

libgraphicstreeview provides a demo application which visualizes a file system Qt model populated with a dummy adjacency model and allows the user to play with visualization parameters:

Check out libgraphicstreeview demo app video

 Whilst already functional, some improvements and new features must still be done in libgraphicsview:

• More realistic implementation of interpolated B-splines. Current implementation is based on Qt’s quad and cubic splines but knot vectors should be used to support smoother and more bundled adjacency edges.
• Background generation of graph layout and edge bundles. QtConcurrent and mapreduce would be a potential support technology for that.
• Filtering of adjacency edges by picking them with a linear selection.
• General profiling and optimization.

KDevelop, Control Flow Graphs, and Hierarchical Edge Bundles

Some years ago I developed the control flow graph plugin for KDevelop. It’s still in playground and, although functional, it suffers from the following drawbacks (part of the reasons for still being in playground):

• Actually it doesn’t provide control flow graphs in its original definition. It rather provides a consolidated control flow graph at the least abstraction level supported by DU-chain.
• It doesn’t support efficient visual escalability. We couldn’t represent large control flow graphs in a restricted region of screen.
• It needs a major refactoring to separate some concerns and make evolution easier.
• All its cognitive information about a KDevelop project can also be carried out by a mirrored radial with hierarchical edge bundles while still solving the previously cited issues. Actually I still need further elaborate that to decide about the future of control flow graphs in KDevelop.

Hierarchical edge bundles in KDevelop already represents the hierarchical project structure but it’s still using a dummy model for adjacency relations. The hierarchical model is quite similar to the ClassModel class used in classbrowser plugin, but (at least by now) there is no need to retrieve information about attributes, and base/derived classes. I’m not an expert in KDevelop architecture but it seems plugins aren’t able to communicate other than by means of KDevIDEExtension. Maybe Aleix or Milian could have any hint for properly sharing ClassModel.

Navigation from radial tree visualization to code still needs to be done, as well as a picking mechanism for filtering adjacency edges of interest. Checkout the following video showing libgraphicstreeview as a KDevelop plugin.

Several future improvements could also be done, such as the assignment of metrics (for example, the CK metrics suite) to visual attributes like color, opacity, size, speed of animation, etc. Evolution information also provides some interesting information about software architecture and software development processes.

Check out KDevelop’s bundled tree view plugin video

I’m watching myself for having a couple hours per week to improve libgraphicstreeview and KDevelop’s bundled tree view. Of course, any help is quite appreciated since I’m still bogged down with PhD duties. You can git clone source code for libgraphicstreeview and KDevelop plugin at:

git@git.kde.org:scratch/sandroandrade/libgraphicstreeview.git

git@git.kde.org:scratch/sandroandrade/kdev-bundled-tree-view.git

See you !

Two years ago the 1st Akademy-BR took place at Praia do Forte (BA), bringing together roughly 30 KDE Brazilian contributors, from coders to promo and translation. In that time, new regional KDE groups in Minas Gerais, Piauí and Rio Grande do Sul had just been formed and fellows like Lamarque, Filipe, and Aracele are still rocking on KDE. Akademy-BR was a nice opportunity to meet those guys in person and try to balance our efforts in pushing KDE and Brazilian community forward. From that time till now things got somehow stabilized (actually put myself as an outlier for that statistics – PhD last year sucks ).

An early attempt to have the 2nd Akademy-BR last year in Minas Gerais couldn’t be successfully acomplished but, as a positive side-effect, that fortunately culminated in the 1st LAkademy: Latin-American KDE Summit. From 27th April to 1st May, we shall meet at Porto Alegre to evaluate our current scenario, plan our actions in 2012-2013 (in particular, I advocate we need a second LA boost like the one we had in Brazil in 2009) and, of course, hacking. KDE contributors from Argentina, Peru, and Brazil are confirmed. Many thanks to CamilaRaw and Henrique for taking care of local arrangements and KDE e.V. and Claudia in particular to support LAkademy.

Stay tuned, see you …

Por Lars Knoll em 3 de Abril de 2012

O Qt Project tem o orgulho de anunciar o primeiro lançamento do Qt 5 Alpha. Todos os recursos do Qt 5.0 já estão implementados e agradecemos desde já os possíveis testes e feedbacks a serem realizados pelos usuários mais avançados das bibliotecas Qt. Esta é uma versão disponibilizada apenas em código-fonte – consulte a seção “Instalação” abaixo para informações sobre como gerar binários ou encontrar aqueles publicados pela comunidade.

Todo o esforço está sendo colocado agora na estabilização, melhorias no desempenho e documentação. Esperamos comemorar o lançamento final durante o Qt Contributors Summit [qt-project.org] (de 21 a 23 de Junho em Berlin). Toda a sua ajuda é bem vinda!

Download

A versão alpha pode ser obtida em vários formatos no release archive [releases.qt-project.org]

Visão Geral do Qt 5

O Qt 4 foi lançado há quase sete anos e continua hoje totalmente atualizado e competitivo, na sua versão estável 4.8. A próxima grande iteração, 5, aprofunda quatro aspectos essenciais do Qt:

• Incríveis capacidades gráficas e de desempenho, especialmente manifestadas em ambientes restritos, como dispositivos móveis. O Qt Quick 2 traz um scenegraph baseado em openGL, um sistema de partículas e uma coleção de efeitos de sombreamento. O Qt Multimedia, Qt 3D e Qt Graphical Effects potencializam esses recursos ainda mais.
• Mais produtividade e flexibilidade para o desenvolvedor, tornando o JavaScript e QML entidades de primeira classe, ao mesmo tempo em que mantém o C++ e o suporte aos Qt Widgets convencionais. O novo backend javascript do Qt, alimentado pelo V8, o Qt JSON DB e o Qt WebKit 2 facilitará a vida dos desenvolvedores HTML5.
• Portabilidade cross-platform é agora mais simples graças à nova estrutura dos módulos Essentials e Add-Ons, além da consolidação da Qt Platform Abstraction [qt-project.org]. Estamos ansiosos para ver o Qt em execução em todos os tipos de ambientes!
• Open Development e Open Governance garantem maior participação no desenvolvimento e teste do Qt 5 por uma crescente comunidade de desenvolvedores, incluindo a Nokia, o projeto KDE, Digia, Collabora, Accenture, KDAB e muitas outras empresas e indivíduos. Hoje, todos nós comemoramos !

O que está sendo lançado ?

O Qt 5 Alpha inclui os seguintes módulos:

• Essentials : Qt 3D, Qt Core, Qt GUI, Qt JS Backend, Qt Location, Qt Multimedia, Qt Network, Qt QML, Qt Quick, Qt SQL, Qt Test e Qt WebKit.
• Add-Ons : Qt D-Bus, Qt Graphical Effects, Qt Image Formats, Qt OpenGL, suporte a impressão, Qt Publish/Subscribe, Qt Quick 1, Qt Script, Qt Script Tools, Qt Service Framework, Qt SVG, Qt System Info, Qt Tools, Qt Wayland, Qt WebKit Widgets, Qt Widgets, Qt XML e Qt XML Patterns.

Versões futuras podem incluir mais módulos. Veja a lista completa de módulos disponíveis em Módulos do Qt Essentials e Módulos do Qt Add-Ons .

Demos e exemplos

Alguns exemplos visuais e ilustrativos para os apressadinhos

• Livecoding video effects with Qt 5 [do youtube.com] - Mostra o Big Buck Bunny como você nunca viu antes, com Qt Quick 2 em ação.
• Pimp my video: efeitos de sombreamento e multimídia [labs.qt.nokia.com] - Veja os efeitos de vídeo do Qt 5 neste blog.
• Qt Graphical Effects no Qt Qt Labs [labs.qt.nokia.com] - O mesmo que acima, porém aplicado a imagens estáticas.
• Raspberry Pi, Qt 5, QML, Shaders [do youtube.com] - Um vídeo criativo mostrando efeitos GL e codificação on-the-fly utilizando uma placa de somente 35 dólares.
• Novas características do Qt 3D [do youtube.com] - Vídeo não tão recente, mas ainda útil para ver o que os designers 3D podem fazer com o Qt.
• Qt MediaHub [qt-project.org] - grande exemplo do poder e da conveniência do Qt Quick. Demonstração funcional e com código disponível, para você aprender as melhores práticas ao utilizar Qt / QML.
• Compilando o Qt 5 para o Playbook - Instruções para testar o Qt 5 e executar seus aplicativos no tablet Blackberry.
• QtonPi [wiki.qt-project.org] - projeto de ponta para a construção de um sistema operacional mínimo e um SDK, otimizados tanto para o Qt 5 quanto para a placa Raspberry Pi.
• Snowshoe [snowshoe.cc] - navegador baseado no Qt 5 utilizável agora no Nokia N9.
• Quasi Engine [indt.github.com] - Uma estrutura baseada no Qt 5 para facilitar o desenvolvimento de jogos 2D fornecendo elementos QML que representam entidades necessárias na maioria dos jogos.

O que há de novo ?

Aqui está só um resumo. A lista completa de funcionalidades pode ser encontrada em Características do Qt 5.

Outros detalhes estão disponíveis em: http://qt.gitorious.org/qt/qtbase/blobs/master/dist/changes-5.0.0

Qt Quick

• O Qt Quick é agora um módulo do grupo essentials, contendo o scenegraph baseado em OpenGL e todos os itens usuais.
• Novo suporte para efeitos de sombreamento baseados em openGL e partículas.
• O QML e o suporte a JavaScript ganharam módulos próprios dentro do grupo essentials.
• O Qt Quick, como no Qt 4.x, está disponível em um módulo Add-On totalmente compatível com o Qt Quick 1.

Qt JS Backend

• Novo módulo com a engine V8 JavaScript, proporcionando um desempenho muito melhor.
• Novas classes QJSEngine e QJSValue.

Qt QML

• Novo módulo que contento a engine QML.
• Muitas melhorias no desempenho e algumas melhorias para suporte a idiomas.
• Em sua maioria é source-compatible, mas quando desenvolvendo itens QML em C++ algumas mudanças são necessárias devido a nova scenegraph.

Qt 3D

• Agora é um módulo em Essentials.

Qt WebKit

• O módulo Qt WebKit agora é baseada em WebKit2. As APIs C++ não foram modificadas.
• Muitas melhorias de desempenho e melhor conformidade com o HTML5.
• O módulo baseado no WebKit1, como no Qt 4.x, agora é chamado Qt WebKit Widget e está disponível como um add-on.

Qt Core

• Classe QStandardPaths disponibilizando locais padrão para arquivos.
• Reconhecimento automático de tipos MIME.
• Verificação em tempo de compilação da sintaxe de conexão de sinais e slots.
• Novo mecanismo para expressões regulares, baseado no Perl.
• Muitas estruturas de dados foram reescritas e otimizadas para um melhor desempenho.
• Suporte ao C++11 onde possível (mas o Qt continua a compilar e funcionar com compiladores C++98).

Qt Gui

• Suporte para superfícies de alto nível através da classe QWindow.
• Suporte nativo a OpenGL.

Qt Network

• Suporte para pesquisas de DNS.
• Classes QHttp e QFtp removidos (eles estão disponíveis stand-alone quando necessário).

Qt Location

• Classes relacionadas a mapas e geolocalização que anteriormente faziam parte do Qt Mobility agora estão contidos em um módulo próprio.

Qt Widgets

• Todas as classes QWidget antigas, baseados no Qt Gui, foram separadas em uma nova biblioteca Qt Widgets.
• Portados para a nova Qt Platform Abstraction.
• Funcionarão normalmente como no Qt 4.x.

Problemas conhecidos

• A compilação do Qt WebKit está desabilitada no Windows, pois sua compilação neste momento é bastante complexa. Estamos trabalhando para tê-la re-ativada e em pleno funcionamento para a versão beta.
• Traduções ainda não funcionam; aplicações Qt aparecerão sempre em Inglês.

Instalação

Esta versão inclui apenas os pacotes fontes, sem binários oficiais. Os desenvolvedores devem construir seus próprios binários – ver Instruções de compilação do Qt 5 Alpha.

Você pode procurar também os binários não oficiais publicados pela comunidade.

Veja também Compilando o Qt 5 a partir do Git [qt-project.org].

Portando código existente

Veja Transição do Qt 4 para Qt 5 [wiki.qt-project.org].

Documentação

A documentação da API para o alpha está disponível em documentação Qt 5.0 [qt-project.org].

Comentários

• https://bugreports.qt-project.org/ é o canal preferido para reportar problemas.
• Verifique também o tópico de anúncio no fórum Qt Developer Network do Qt 5 Alpha.

Os desenvolvedores que usam Qt estão convidados a aderir a lista de discussão para compartilhar impressões e buscar ajuda da comunidade.

“Foram tantos pedidos que nós alcançamos nossa capacidade de produção inicial e tivemos que fechar o programa de pré-venda, por enquanto”, disse o líder do projeto Spark, Aaron Seigo.
O Spark terá uma tela multi-touch capacitiva de 7″, um processador ARM CortexA9, 512MB de RAM e 4GB de armazenamento interno. Um slot de cartão SD, várias portas USB e uma mini-HDMI, e espera-se ser vendido por €200.
“Assim que a efetivação da compra puder ser feita, estaremos enviando e-mails para os inscritos na pré-venda, logo, quem se inscreveu primeiro receberá seu Spark primeiro.”

Mais informações sobre o Spark e sobre as inscrições, podem ser visualizadas no blog do desenvolvedor do Spark: aseigo.blogspot.com

Here in Brazil there are quite a lot of companies that makes money selling free software, All public schools in brazil uses KDE and KDE Edu software, but nothing was donated back to the project. This is not illegal, I know that, but it looks immoral.

2 – That Free Software Projects stops fighting each other, and help each other instead.

Just like KDE and Gnome had a past of fighting and a few scratches are still made, they are making things better by creating and using standard, not perfect yet, but they are trying.

3 – That no free software project be created with the intuit of killing another free software, help the first instead.

4 – That Students around the world be more focused and willing to help free projects as interns.

5 – That Algorithm and OO teachers stops using Java for everything and saying that java is good because you ‘code once, run everywhere’, and please, stop teaching UI programming with Swing…

Those are my wishes.

Today, at 2pm, GMT-2, there were a discussion on the #kde-brasil, at freenode to talk about the upcoming Akademy-BR. the log of the meeting is here, mostly in portuguese, but there were some Argentinian dudes there too. =)

Now, we are looking for a place to hack on Porto Alegre, if you know anything, please get in contact with Camila or HSantana in the #kde-brasil, on freenode.

What will be discussed:

• Location
• Dates
• Hack Sprint
• Promo Sprint

Don’t miss if you like KDE and live in latinamerica =)

Lamarque worked like hell for painless Network Management

Sandro Andrade has two ( \o/ ) Research Projects for Musical Education funded by the Brazilian Intisiute of Research, for KDE-Edu

Filipe Saraiva worked for a Backend on Cantor, a good example of how a GSoC for another project ( Octave ) can help our little project =)

I fixed a bunch of bugs in a few KDE apps, specially on my kid, Rocs,

Helio Castro supervisioned us,

And the usual amount of Talks, Presentations and Classes on use of Qt Library and KDE Development.

it would be too large to write here everything that we done in 2011, I envy Lamarque for always blogging, I always forgot.

My plan is to do One Post Per Week, with pictures and all.

Latinoware 2011

No último dia 14 de Outubro o KDE completou 15 anos de muito trabalho, inovação e diversão é claro ! O KDE Brasil aproveitou a 8a. Edição da Conferência Latino-Americana de Software Livre (Latinoware 2011) para realizar uma grande festa ! Este ano, mais do que nunca, tivemos um stand super bacana: banner dos 15 anos do KDE, TV para demonstrar as feature mais legais do KDE e passar vídeos bacanas, diversos “apetrechos” do KDE: camisas, pins, adesivos, cartões postais, etc. O IV Fórum KDE Brasil – Edição Latino-Americana trouxe para o Latinoware uma série de palestras e mini-cursos sobre as tecnologias Qt e KDE.

Banner comemorativo dos 15 anos do KDE

Nosso stand

KDE swags

Nosso amigo Juan do KDE-Argentina

Na quarta-feira, dia 19, tivemos o mini-curso “Desenvolvendo Aplicações Mobile com Qt 4.8″, ministrado por Sandro Andrade e Luis Paulo Torres. No mini-curso foram apresentados os principais recursos do Qt Mobility 1.2 que promovem o desenvolvimento cross-platform de aplicações para o Symbian, Maemo, Meego e também Android e iOS. Laboratórios práticos de acesso aos diversos sensores (acelerômetro, orientação, etc), dados de contatos e integração com GPS foram realizados. A participação do público foi excelente: 20 participantes (sala lotada) e mais alguns de pé.

Mini-Curso ”Desenvolvendo Aplicações Mobile com Qt 4.8″

Também na quarta-feira Filipe Saraiva apresentou a palestra “KDE-Edu: a visão KDE dos softwares aducacionais”, onde os aplicativos educationais e tendências futuras do KDE na educação foram apresentados.

Palestra “KDE-Edu: a visão KDE dos softwares aducacionais” com Filipe Saraiva

Ainda no primeiro dia o Open Source Rock Festival aqueceu os ânimos dos participantes.

Open Source Rock Festival

Participantes ilustres

O Latinoware 2011 trouxe uma interessante tecnologia (E-Take) para o favorecimento da redução do consumo de papel no evento. Cada participante recebeu, no momento do credenciamento, um pequeno dispositivo utilizado para solicitar material em meio digital previamente disponibilizado pelos stands. O participante aproximava o dispositivo de um receptor presente em cada stand e automaticamente o material era enviado para o seu e-mail.

Na sexta-feira, dia 21, ocorreu o Forum KDE propriamente dito com a palestra de abertura “15 anos de KDE: o que construimos ? para onde iremos ?”, apresentada por Aracele Torres. Na apresentação, revisitamos toda a trajetória do KDE ao longo deste período, destacando as grandes conquistas e os projetos mais desafiadores.

Palestra “15 anos do KDE: o que construimos ? para onde iremos ?”

Logo em seguida a palestra “KDE Frameworks 5: o que você ganha com isso ?” ministrada por Sandro Andrade, apresentou as facilidades atualmente disponibilizadas pelo KDE Platform 4 e as modificações previstas na próxima liberação major das tecnologias KDE. APIs para multimídia (via Phonon), I/O síncrono e assíncrono, local ou remoto (KIO), controle de GUIs via XML (KXMLGUI), obtenção e upload de artefatos na web (Get Hot New Stuff), utilização de plugins e KParts foram demonstrados através de códigos exemplo. Aspectos sobre modularização e definição explícitas de dependências na futura versão da plataforma (KDE Frameworks 5) foram também ilustrados. Uma das metas é favorecer ainda mais a execução de aplicações KDE no mais amplo espectro de dispositivos.

Palestra “KDE Frameworks 5: o que você ganha com isso ?”

Dando continuidade ao IV Fórum KDE Brasil nosso amigo Juan Muguerza, do KDE Argentina, apresentou a palestra “Owncloud: cria a sua própria nuve com KDE”, onde a soluções opensource completa do KDE para computação na nuvem foi apresentada e discutida.

Palestra “Owncloud: cria a sua própria nuve com KDE”

Encerrando nossa participação no VIII Latinoware, a palestra “Plasma Active: o KDE chega ao seu tablet” ministrada por Sandro Andrade apresentou a recém-lançada versão do workspace Plasma totalmente dedicado aos tablets e outros dispositivos móveis. As principais facilidades para criação de activities e ligação de URLs e aplicações às activities presentes foram demonstradas. Versões mobile das aplicações KDE Kontact e Calligra trazem uma maior facilidade de utilização nos tablets e ratificam o Plasma como tecnologia bastante promissora e certamente presente em uma ampla faixa de dispositivos em um futuro próximo.

KDE Plasma Active em ação

Como não poderia faltar uma comemoração compatível com todas as conquistas do KDE não poderia deixar de estar presente

Antes

Depois

E até o próximo Latinoware

Update: ainda temos algum material do KDE disponível para venda (camisas, pins, cartões postais, adesivos, etc). Fotos abaixo, interessados devem contactar sandroandrade AT kde DOT org

]]> http://liveblue.wordpress.com/2011/10/26/kde-comemora-seus-15-anos-no-latinoware-2011/feed/ 2 sandroandrade DSC01035 20090102_001 20090102_004 20090102_002 20090102_003 DSC01032 DSC01050 IMGP2228 DSC01054 Aracele Torres - VACY-2 DSC01131 DSC01143 500px-PA4 DSC01167 DSC01171 DSC01162 estampa2balao costas IMGP2253 IMGP2254 IMGP2255 IMGP2256 http://liveblue.wordpress.com/2011/10/21/qt-project-esta-no-ar/ http://liveblue.wordpress.com/2011/10/21/qt-project-esta-no-ar/#comments Fri, 21 Oct 2011 19:58:05 +0000 Sandro Andrade http://liveblue.wordpress.com/?p=1192 ]]> Por: Lars Knoll

O Qt Project está no ar !

Estamos felizes em anunciar que o Qt Project foi oficialmente lançado. A partir de hoje, o desenvolvimento do Qt será governado como um projeto verdadeiramente open source.

A partir de hoje está disponível o qt-project.org – um site que centralizará todas as informações sobre o desenvolvimento do Qt, fornecendo a mesma infra-estrutura e processos para qualquer um que queira contribuir com o Qt.

Agora que estamos aqui, o que vem depois?

Se você está interessado em participar e se tornar parte da comunidade do Qt Project um bom lugar para começar é o site qt-project.org.
Este site fornece uma boa visão geral sobre como começar e como se tornar parte da comunidade e contribuir para o Qt.

Se você já tiver trabalhado com Qt, você provavelmente terá uma conta no Jira, nossa ferramenta de rastreamento de bugs. Esta conta é necessária para obter acesso ao local central onde todo o desenvolvimento acontece: codereview.qt-project.org.

Nosso servidor Gerrit codereview.qt-project.org vai funcionar como o local central para onde os patches são enviados e então revisados ​​e
testados. Todos que têm uma conta Jira pode enviar patches para codereview.

Patches podem ser revisados por qualquer um, e, finalmente, aceitas ou rejeitadas pelos Mantenedores. Você também vai notar que já temos
alguns não-Nokians como Aprovadores e Mantenedores. Gostaria de especialmente mencionar que Thiago, mantenedor de QtCore (biblioteca utilizada em todo o Qt), não está trabalhando para a Nokia. Isto é uma evidência mais tangível do que o Open Governance significa. Espero poder ver ainda mais não-Nokians se tornando Mantenedores no futuro.

Para obter detalhes sobre como contribuir, acesse http://www.qt-project.org. Por enquanto temos apenas algumas listas de discussão disponíveis em lists.qt-project.org, mas provavelmente isso mudará para acomodar listas mais especializadas à medida que avançamos. A lista mais importante é a lista de discussão geral de desenvolvimento development@qt-project.org. Note que a lista de discussão de desenvolvimento também é membro da lista de discussão de anúncios, assim você irá automaticamente receber as notificações de novas versões.

Continuamos a usar o Jira para rastreamento de bugs e de requisitos. A instalação atual no bugreports.qt.nokia.com será movido nas próximas semanas também para o Qt Project.

A Verdadeira Abertura

O Qt Project é um projeto verdadeiramente aberto. Estamos convidando a todos para participar e ajudar a fazer do Qt um produto melhor.

Todo o desenvolvimento acontecerá em um local central, com acesso para todos ao mesmo tempo. Não há mais um fluxo de código separado para os Nokias e para os “outros”. O que você vê é exatamente o que vemos. Discussões, decisões e roadmap tudo acontecerá na comunidade, pela comunidade e para a comunidade. Qualquer pessoa pode ser um colaborador, e até mesmo um Mantenedor se mostrar mérito para isso.

Converse conosco sobre o Open Governance no Qt Developer Days

Sessões sobre o Open Governance do Qt Project acontecerão no Qt Developer Days e eu também vou estar falando sobre isso durante a minha palestra. Se você está vindo para o evento você terá a oportunidade de aprender mais e se envolver na discussão. Se você está considerando vir ao Qt Dev Days esta discussão é uma das muitas boas razões para nos encontrarmos por lá !

Conclusões e agradecimentos

Estamos extremamente felizes em ver que este movimento finalmente agora aconteceu. Gostaria de aproveitar a oportunidade para agradecer a todas as pessoas que ajudaram a tornar isso possível. Muitas pessoas contribuíram, mas alguns devem ser especificamente mencionados: Thiago Macieira por dirigir os trabalhos iniciais sobre o Open Governance, Marius Storm-Olsen por assumir grande parte do trabalho, Cristy Hamley, por lidar com todas as questões legais e Olivia Puntanen pela gestão do projeto. Obrigado a todos.

Estamos ansiosos para começar um novo capítulo no desenvolvimento do Qt e animados para trabalhar com todos vocês no sentido de tornar Qt um produto ainda melhor.

It’s been a while since my last post. Just finishing some boring academic duties, I hope to be returning soon to KDE hacking again. In the meanwhile, we managed to prepare some cool stuff for KDE participation at Latinoware 2011 (Latin-American Conference on Free Software). KDE have been attending Latinoware in a more structured way since 2008. It’s the second biggest conference on Free Software in Brazil (roughly 4000 participants) and we are usually granted with enough room for talks and a cool roomy area for KDE booth arrangements.

This year we were close to my dreams’ KDE booth . A nice KDE banner + amazing KDE 15 years t-shirts + a lot of KDE swags + big TV set to show off great KDE videos.

Our banner (thanks Wade)

Latinoware 2011 has deployed an interesting technology to spread out promotional material from all booths whilst yet reducing paper consumption during the meeting. All attenders received a small device configured with their personal email addresses which could then be used to request information by putting it closer to sensors installed at booths. The desired promo stuff are then sent to the participant’s email (we were previously asked to provide all digitized material to Latinoware organizing staff).

KDE stuff

Booth Heading

As usual, a Call for Presentations was issued at KDE Latin-America mailing list asking for talks and short-courses proposals from KDE communities in Argentina, Chile, Peru, and others. This year, we have Juan Muguerza from KDE Argentina presenting a talk about OwnCloud. As for the KDE program at Latinoware 2011 we had yesterday a short-course about “Developing Mobile Applications with Qt” which grabbed roughly 25 participants willing to deploy Qt applications in their beloved devices. Filipe Saraiva presented a talk about KDE-Edu and tomorrow we are going to have talks about KDE 15 years, KDE Frameworks, OwnCloud and Plasma Active.

Our fellow Juan from KDE-Argentina

The Open Source Rock Festival at Latinoware Opening

So, that’s all so far. See you …

Um dispositivo móvel deve ser mais que uma simples coleção de aplicativos. Ele deve refletir quem você é. O Plasma Active traz o melhor para o seu tablet, a partir da novíssima tecnologia de Activities baseadas em touch-screen.

Uma Activity de planejamento de férias

No dia 09 de Outubro de 2011 o primeiro lançamento do Plasma Active se torna publicamente disponível. A interface touch screen do Plasma Active One é muito mais que um lançador de aplicativos. Assim que o seu dispositivo é ligado, ao invés da exibição tradicional do grid de aplicações, é exibido o gerenciador de Activities apresentando o seu projeto, tarefa ou idéia atual. Com as Activities, você pode reunir todos os documentos, pessoas, sites web, conteúdo multimídia e widgets, relacionados a um tópico, em um único lugar, construíndo visões personalizadas e interativas da sua vida. Com o Plasma Active as possibilidades são ilimitadas. Você pode adicionar quantos elementos você quiser a uma Activity, com o auxílio da sua funcionalidade de scroll ilimitado. Você pode criar quantas Activities quiser e alternar entre elas via touch-screen, utilizando o Activity Switcher.

Adicione conteúdo a sua Activity

Você escolhe o objetivo de uma Activity: planejar suas férias, trabalhar em um projeto da escola ou do trabalho, organizar as fotos da festa bacana do fim de semana, manter informações sobre suas redes sociais ou organizar seus sites preferidos de notícias. Crie uma Activity, informe o seu nome e seu papel de parede e comece a adicionar seus apetrechos ou diretamente através do botão “Adicionar” ou usando a interface Share Like Connect.

Compartilhando uma foto através do Share Like Connect

Share Like Connect é um grupo de três pequenos ícones sempre disponíveis no painel superior. Eles permitem que você rapidamente conecte o que você está fazendo a qualquer Activity – sites web ou imagens sendo visualizados, documentos, etc. Use o Share Like Connect para registrar seus bookmarks. Envie facilmente o que você está visualizando, por e-mail, para pessoas da sua lista de contatos.

Complementando as Activities, o Plasma Active disponibiliza um lançador rápido e eficiente de aplicações e inclui, por padrão, uma variedade de aplicativos para você usar e se divertir. Basta puxar o painel superior para baixo para tornar a área de seleção de aplicações visível. A seleção de aplicações apresenta as aplicações atualmente em execução, de modo que você pode facilmente alternar ou fechar os aplicativos. Puxando a seleção de aplicações um pouco mais para baixo faz com que o lançador de aplicações fique visível. Ele apresenta uma lista de ícones similar às outras interfaces para tablets e smartphones. A barra de busca integrada permite que você facilmente busque por aplicações instaladas no sistema.

O Peek and Launch permite que você alterne entre aplicações em execução e inicie outras

Quando uma aplicação é iniciada ela automaticamente se conecta à Activity atual. Aplicações relacionadas são mantidas em grupo e fora da sua visão quando você alterna para uma Activity diferente. O Plasma Active traz produtividade imediata para você. Várias aplicações estão por padrão incluidas – navegador web, visualizador de imagens, player de áudio e vídeo (Bangarang Active), visualizador de documentos com funcionalidades simples de edição (Calligra Active [beta]), total controle de e-mail e calendários (Kontact Touch) e diversos jogos divertidos. Estas aplicações são totalmente otimizadas para a interface touch screen. Centenas de outras aplicações estão gratuitamente disponíveis através dos repositórios on-line, embora a maioria delas não estejam ainda otimizadas para touch-screen.

Kontact Touch integra email e groupware ao Plasma Active

Plasma Active é projetado e construído de forma aberta e é lançado sob a forma de software gratuito e de código aberto. Por trás das idéias do Plasma Active está uma comunidade vibrante de participantes e empresas trabalhando em conjunto por um único ideal: a criação de aplicações incríveis para os dispositivos atuais. Não há lock-ins proprietários ou segredos na frente dos esforços de projeto e desenvolvimento, somente uma fantástica experiência de usuário que você pode usar, se divertir e participar.

Como Obter o Plasma Active One

Imagens nas versões instalável e live estão disponíveis para download. Instruções detalhadas de instalação podem ser obtidas na página Instalação do Plasma Active. Tipicamente a instalação consiste simplesmente na inserção de um pendrive USB bootável no tablet, uma reinicialização e seguir as instruções na tela.

É também possível rodar o Plasma Active em uma máquina virtual para propósitos de teste e avaliação. Para maiores informações, bem como os problemas dessa abordagem, por favor refira-se à página Plasma Active em máquinas virtuais. Recomendamos fortemente, entretanto, a execução do Plasma Active em um tablet para melhor experiência.

O Futuro do Plasma Active

O Plasma Active One é mais um passo da longa jornada que a equipe KDE Plasma criou desde o início do projeto em 2007, originalmente para criação de um novo shell desktop. E não chegamos no fim desta caminhada. O Plasma Active Two será lançado em meados de Dezembro de 2011 com o Plasma Active Three programado para ser lançado no terceiro trimestre de 2012.

O Plasma Active Two terá suporte a recomendações automatizadas a Activities, permitindo que o Plasma Active ajude você a coletar e adicionar informações e documentos relevantes às suas Activities. Teremos também a visualização, filtragem e ordenação melhorados de todos os tipos de mídias e informações acessíveis no Plasma Active. Outras funcionalidades serão também desenvolvidas para o Share Like Connect baseado em plugins. Esta versão irá também conter melhorias relacionadas a estabilidade e desempenho, bem como correção de bugs.

O Plasma Active Three será outro lançamento importante onde focaremos nos desafios de segurança de dispositivos, de modo a manter os seus dados seguros e sob controle. Na versão três, começaremos a implementação de forms factors adicionais, para suportar settop boxes e handhelds. O Plasma é construído com a filosofia de “interfaces altamente modularizadas, re-utilizáveis e re-integráveis”. Isto nos permite mover rapidamente de um tipo de dispositivo para outro, mantendo sempre uma ótima experiência de usuário. Pretendemos explorar ao máximo esta flexibilidade nas futuras versões.

Em ciclos de desenvolvimento futuros, um maior número de aplicativos Active e widgets estarão disponíveis. Desenvolvedores de aplicações já existentes estão convidados a se juntarem a nós na “ativação” de suas aplicações para suportar touch-screen e outros form factors. As melhores e mais úteis aplicações serão lançadas nas próximas versões do Plasma Active. Um sistema fácil para download de outras aplicações estará também disponível.

Planejamos também incluir o ARM como arquitetura oficialmente suportada, em adição às plataformas Intel já contempladas. Este esforço está sendo executado em conjunto com as tarefas de redução do footprint do sistema operacional necessário para rodar o Plasma Active. Adicionalmente, estamos no processo de desenvolvimento de uma especificação clara e bem documentada sobre os requisitos subjacentes de sistema operacional necessários para uma boa execução do Plasma Active.

Navegador Web com suporte a touch do Plasma Active

Como Contribuir com o Plasma Active

Plasma Active é um projeto aberto: todo o projeto, planejamento e desenvolvimento é feito em um ambiente de trabalho baseado em consenso. Colaboradores da comunidade e empresas de criação de dispositivos ou aplicativos são bem vindos e capazes de participar da sua própria forma. Se você deseja criar novos widgets, add-ons para o Share Like Connect, novas aplicações, suportar novos dispositivos ou criar uma experiência de usuário totalmente nova usando o Plasma Active, estaremos sempre prontos para lhe receber. Esforços para testes, estabilização, análise de usabilidade e projeto gráfico para os softwares já existentes são também áreas de potencial colaboração.

As bibliotecas utilizadas pelo Plasma Active são licenciadas sob a LGPL, permitindo uma variedade de opções de licenciamento e possibilidades de extensão e configuração. Você pode contactar a equipe do Plasma Active na nossa lista de discussão ou no canal #active do irc.freenode.net. Existe também o fórum KDE de auxílio ao usuário. Solicitações privadas e de imprensa podem ser enviadas a Sebastian Kügler (sebas@kde.org) e Eva Brucherseifer (eva.brucherseifer@basyskom.de).

Blinken é um divertido jogo infantil com suporte a touch screen

Compatibilidade de Hardware

As imagens do Plasma Active One foram testadas e são suportadas nos dispositivos WeTab, ViewSonic ViewPad, ExoPC e Lenovo Ideapad. Mais informações sobre compatibilidade de dispositivos podem ser encontradas aqui. O Plasma Active deve funcionar bem em outros dispositivos baseados em Intel. O suporte a dispositivos ARM está ainda em desenvolvimento. Entretanto, o Plasma Active foi instalado e executado com sucesso no Nokia N900 e outros dispositivos ARM.

Compatibilidade de Software

Praticamente qualquer software disponível para a plataforma Linux pode ser executado no Plasma Active. Recomendamos aplicações baseadas no Qt e no KDE visto que elas apresentam uma melhor integração com o Plasma Active One, o qual é também baseado no KDE Platform 4.7 e Qt 4.7. Outras aplicações, entretanto, executam e funcionam da mesma forma que funcionariam em qualquer outro sistema baseado no Linux. Isso inclui aplicações em linha de comando, acessíveis através do terminal com suporte a touch já presente no Plasma Active.

O Plasma Active é compatível com os workspaces do Plasma Desktop e Plasma Netbook. São todos baseados no mesmo framework, compartilhando mais de 95% do código-fonte. Esta é uma abordagem radicalmente diferente para similaridade de interfaces entre dispositivos. A maioria dos outros produtos para tablets ou são isolados (compartilhando pouco ou nada com outras interfaces de usuário) ou tentam utilizar interfaces desktop em displays pequenos. As interfaces baseadas no Plasma, entretanto, são criadas para tipos específicos de dispositivos mantendo ainda a grande maioria do código-fonte e esforços de engenharia. Consequentemente, widgets e aplicações escritas para o Plasma Desktop ou Netbook podem ser executadas normalmente em dispositivos com o Plasma Active.

Agradecimentos

O Plasma Active One não seria possível sem o inacreditável apoio da comunidade Plasma e sem o suporte financeiro e de desenvolvimento da basysKom e open-slx. O Plasma Active é construído com base nos excelentes frameworks do KDE e Qt, nos dando excelentes pilares para iniciar qualquer trabalho. Estamos muito felizes em conviver com milhares de pessoas que vêm colaborado com as comunidades KDE e Qt ao longo dos últimos 15 anos. Agradecemos também aos esforços que resultaram na criação do MeeGo OS e do Open Build Service, fundamentais para a finalização e lançamento do Plasma Active One.

Sobre o KDE

O KDE é uma equipe internacional de tecnologia que desenvolve software livre para computadores desktop e portáteis. Entre os produtos desenvolvidos pelo KDE estão um sistema desktop moderno para as plataformas Linux e UNIX, um amplo conjunto de aplicações para escritório e groupware e centenas de títulos em categorias tais como Internet a aplicações web, multimídia, entretenimento, softwares aducacionais, editoração gráfica e desenvolvimento de software. As aplicações do KDE são traduzidas para mais de 60 idiomas e são desenvolvidas com foco na facilidade de uso e princípios modernos de usabilidade. As aplicações do KDE4 rodam nativamente no Linux, BSD, Solaris, Windows e Mac OS X.

Avisos Legais. KDE® e o logo K Desktop Environment® são marcas registradas do KDE e.V. Linux é marca registrada de Linus Torvalds. UNIX é marca registrada de The Open Group nos Estados Unidos e outros paises. Todas as outras marcas e copyrights utilizadas neste anúncio são de propriedades dos seus respectivos donos.

Contatos

Get in the wave, Program a bit, drink a coconut.

What if konqui played in a Afro Percussion Band?

What about some Yerba, Mate?

Konqui could be an outlaw from the drylands

Get some Cheese, Get some Programming....

“]

one two three little konquis.

All Drawings were done by a dearest friend of mine, Manuela Leite, If you liked the drawing, please thank her for that. All konquis are in Creative Commons, and I’ll upload the tarball to kde git repositories as soon as the promo – team tells me where to upload it.

I’ve published some wallpapers made from the pictures I took while in Berlin on kde-look.org, and more will come in the following days. Just search for the #ds2011 keyword.

Some samples:

Tiger (1920 x 1080)

Lilypad (1920 x 1080)

I’m a bit short in time, so I’m just publishing them in a single size, but I will provide them in other resolutions as well when time permits.

Enjoy!

Humboldt University

Yeah, I know it’s a bit too early for this, but from this year’s experience at the Berlin Desktop Summit, I’m not going to miss the next Akademy.

So, I’m finally back home after the Desktop Summit! It was the first time I met most of the KDE devs and even had the opportunity to help a bit in the organisation of such a wonderful conference.

The location chosen was really nice: Berlin is a beautiful city, German people is very receptive (and helpful!) to foreigners, its transport system is a dream (specially if you compare to what we have here in Brasil, unfortunately), and one can easily get all kinds of food. Everything without knowing a single word in German!

Chani's lightning talk

The Humboldt University provided us with a good Internet connection and big rooms for the talks and for the hacking sessions and is located in the hearth of Berlin, with lots of historical buildings, pubs and restaurants nearby, making our stay in Berlin a pleasure. The conference featured a lot of high quality talks and, together with the workshops, BoF’s and experience exchange, gave everyone a nice overview of the projects we usually don’t know much (both in KDE and Gnome).

Thomas Thym talk about conflict management

Another good thing is that we had quite a lot of Brazilians attending the conference this year, so it looks like our local community is growing up \o/. Keep up, guys!

In the following picture, you can see (from left to right) Ufa, Camila Ayres, Filipe Saraiva, Aracele Torres, Lamarque Vieira and sitting on the floor you’ll find me.

Brazilians @ Berlin Desktop Summit

That was my first participation on a Desktop Summit/Akademy, but I’ll attend the next year’s Akademy for sure. It was a very valuable experience and interacting with/knowing the KDE people is really motivating. See you on Akademy 12!

Victory!

And it was about time to have a meeting, and a meeting has ben called. It will be in the 18 September, at 8 p.m. UTC, in the #kde-cwg channel, please be there. it We also have an awesome wiki were all things related to the meeting should be.

So, if you like Communities, if you are a Community, If you dislike them, or if you are a fellow developer that likes want help in your app by means of a groovy team of community workers, be there.

- Organizing a new KDE-Coders group in the UniverCidade university;

- Talking with two *HUGE* companies that uses KDE for it’s image and interview ( not finished yet );

- Qt & KDE programming course in Rio de Janeiro;

- Qt & KDE programming course in São Paulo;

- Qt & KDE programming course in Bahia;

About 4.7 and rocs:

the 4.7 version of Rocs has another developer helping in, Andreas Cord Landwehr, A *TON* of new features and a *TON* of bugfixes.

New Features:

- Improved visualization now can handle much more nodes on screen

- New plugin for auto-generating a few types of graphs

- New plugin for auto-managing connections on the nodes

- List and Graph types reworked

- possibility to *not* use a color in graph.

- more than 100 bugs fixed compared to the 4.6 version

That’s all for a while, folks.

Andreas é o carinha legal da semana. =)

Now that it’s around for some time, I’d like to get some feedback about usability. Is it easy enough to discover? Does it gets in your way? Should I add a setting to enable/disable it, or even remove it completely? Comments, please

Não teve nada do congresso ainda, afinal todos acabaram de chegar. Amanhã começa de verdade.

I Came to Rio de Janeiro 3 weeks ago, because Petrobras got in contact with Lamarque about a Qt course in here in Rio, since Lamarque was busy at the time, he delegated the course to me. The flight was confortable, just one hour flying from são paulo, but then things started to get messy. somebody stole my backpack in the airplane cabin, I talked with the cabin crew about it and they allowed everybody to leave, and WTF, my backpack with my laptop and everything inside. the flight arrived at 10pm, and I got out of the airport at 1am, sleeping in a overpriced – hotel near by. In the morning I had to give my first lesson but my Material was on the backpack. What to do? Well, luckly I know C++ well enougth to talk without an paper-reminder of what I need to say.

So I came to CENPES, the Centro de Pesquisas da Petrobrás in Ilha do Fundão, the artificial island where the Federal University of Rio de Janeiro main campus is located. The island was actually three islands that were joined together to build the campus, and has 5.238.337,82m² of total area. this is bigger than some countries.

Petrobras is the main Oil Company in brazil, and one of it’s primary research facilities is located in that island, and it was where I went to give a class. I was terrified, I’v never entered in a company so big before and I wanted everything to be perfect, but perfection to perfection, I nearly broke my feet one week before the classes started. take that for perfection. first class I gave sitted in a chair, trying to not hurt my feet more.

The first lesson was about Remembering C++ and Advanced C++ with meta-programing with templates. the file with all lessons about c++ is in the resources page, also worried about the feet and the stolen backpack, I went back to the airport, they have located the guy that grabbed my backpack by mistake, because he forgot his on the airplane cabin, but his mother was terrified that he could get lost in a city that he doesn’t know so well, after all, he was too young to walk around and go to the airport to give back my backpack. In the end he was 23, but who am I to say that he was not that young? I phoned them and they told me that they could only give me back my back pack in the next day, then I got pissed off, and almost lost my temper. I said ‘sudo, woman, give me back my backpack.’ if you change ‘sudo’ by ‘if you don’t get me my backpack with everything inside today, I’ll go there with the police’, you will understand everything that happened. and Magically, my backpack appeared with everything just one hour later.

I got happy, I got back to my friend’s apartment ( inside a commercial building. ) talked him about that history and went to sleep untill next morning, where the Qt Course was going to start. ( if you want to take a look about the 60h Qt course, it’s on our resource page ).

The Course at Petrobras transcourred well, I teached them for two weeks in the main topics of Qt, like QtCore, QtConcurrent, GraphicsView, Widgets, Model View, Scripting, Animation Framework. I Had only 5 students, that were being trained to train the rest, one of those Students was a Professor of a nearby University, and invited me to give a talk about KDE and Qt there, that’s what I’ll be doing today at 19 pm, in the UniverCidade near the Carioca Station, if anybody that reads this wanna go, feel free to. He loved the KDE-Edu initiative, and already moved his students to help the project. the debut of the Univercidade – Edu team should happen this year ( I hope. ).

After three weeks lecturing, I’m exausted. it was a nice, fun and enjoyable experience, that I’ll sure wanna do again. but cant rest now, there’s the talk on UniverCidade that I need to finish

Estamos felizes em anunciar que o KDE mais uma vez participará do GSoC. Este é o nosso 7º ano no programa. Confira também as outras 174 organizações de software livre participantes! Vamos, mais uma vez, fazer deste um excelente verão.

Se você é um estudante agora é a hora de começar a trabalhar em sua proposta. Você pode ou sugerir a sua própria idéia ou se inspirar naquelas presentes em nossa página de idéias. Uma vez decidido em qual idéia você pretende trabalhar comece a sua pesquisa e escreva a sua proposta. Obtenha regularmente feedbacks da equipe que pretende trabalhar. Se você quiser escrever uma proposta para a sua própria idéia sugiro fortemente que entre em contato com a equipe o mais cedo possível, para ter certeza que é algo que eles têm interesse e para obter algum retorno. Se você tiver dúvidas estamos sempre no nosso canal de IRC “#kde-soc” na freenode ou junte-se a nós na lista de discussão kde-soc@kde.org. Para mais informações sobre idéias específicas tente contactar diretamente a respectiva equipe, através do seu canal específico de IRC ou lista de discussão. Para obter informações gerais sobre GSoC visite http://www.google-melange.com – prestar especial atenção ao cronograma.

Se você é um mentor seus próximos passos são: 1) inscrever-se na lista de discussão kde-soc-mentor@kde.org; 2) fazer seu cadastro no site http://www.google-melange.com e solicitar sua inscrição como um mentor para o KDE; 3) contacte um dos administradores para aprovar seu pedido. Em caso de dúvidas contacte a equipe de administradores no canal “#kde-soc” ou via kde-soc-mentor-owner@kde.org. E, claro, alunos o procurarão com perguntas sobre suas propostas . Abaixo você pode encontrar um fluxograma com os passos mais importantes do programa. Verifique também o cronograma do GSoC 2011.

Após o anúncio recente da Nokia sobre a sua futura estratégia de desenvolvimento para smart-phones, o KDE tem recebido uma série de perguntas. Muitas dessas questões são relacionados ao futuro do compromisso entre o KDE e o framework Qt. Nesta mensagem, definimos o que vemos como um futuro brilhante para o Qt e o KDE.

Qt

Passamos a utilizar o Qt em 1996 por constituir o melhor framework para desenvolvimento de software. Hoje, ainda continua sendo. Ao longo dos últimos 15 anos o KDE vem trabalhando para assegurar que o Qt esteja sempre disponível, levando à criação de acordos como aqueles que sustentam a KDE Qt Free Foundation. O futuro do Qt foi ainda mais reforçado nos últimos anos por decisões da Nokia que passaram a liberá-lo sob a licença LGPL e que iniciaram o processo de dar, à comunidade, uma maior influência através do processo de Open Governance. Estamos trabalhando com nossos parceiros para acelerar este processo e tornar a Open Governance uma realidade. Neste ínterim, congratulamo-nos com o compromisso contínuo da Nokia com o Qt, assim como seu contínuo apoio ao KDE, como patrono e como patrocinador da nossa conferência anual.

KDE

Hoje o KDE enfrenta novos desafios e oportunidades. Computadores desktop tradicionais e laptops já não são os únicos meios para que usuários trabalhem com documentos, se divirtam e interajam socialmente. Inovações como netbooks, tablets e smart-phones cada vez mais poderosos mudaram o uso do computador, introduzindo novos form factors e novos casos de uso. Pela primeira vez desde que o KDE foi fundado temos a chance de moldar a natureza de utilização do computador, ao invés de competir com os paradigmas de computação já estabelecidos.

O nosso framework Plasma nos coloca numa posição privilegiada para desenvolver interfaces inovadoras e modernas para smart-phones, sistemas embarcados em veículos, computadores desktop, computadores portáteis, media centers e muito mais. Poucos, se algum, dos nossos concorrentes têm um framework para interfaces de usuário que é tão portátil, atraente e fácil de desenvolver com o nosso. A peça fundamental do Plasma e da portabilidade das nossas aplicações é o Qt. O código desenvolvido para uma plataforma pode ser executado com mudanças mínimas (se alguma) em plataformas legadas, como o Microsoft Windows e Mac OS X e, fundamentalmente, em Linux e outras plataformas livres que variam desde dispositivos portáteis até computadores desktop mais poderosos. As recentes inovações do Qt, como o Qt Quick, fazem com que designers e desenvolvedores transformem suas idéias em aplicações e as ofereça aos usuários de uma forma muito mais fácil. O KDE está apenas começando a tirar proveito dessas novas oportunidades.

O Futuro

O Qt continua sendo o pilar sólido e multi-plataforma de tudo o que fazemos. Combinado com as tecnologias do KDE, acreditamos que o Qt é o framework mais convincente para o desenvolvimento multi-plataforma de aplicações. Nunca houve uma época melhor para moldar o futuro da computação. Participe e faça do futuro um futuro que é livre.

After waiting a couple of weeks until students return from vacation we finally could enjoy a nice sunset followed by some beers, acarajés, and of course celebrate our beloved newborn, talk about free software and amenities in general. The party took place at “Largo da Dinha”, neighborhood of “Rio Vermelho” – quite popular place for bohemians (only by coincidence is in the neighborhood where I live ).

A pretty nice photo from my home just before going out to the release party

Largo da Dinha – Rio Vermelho

KDE 4.6 Release Party

See you …