Free Software

Judge Lucy Koh, the presiding judge in the Apple v. Samsung litigations, warned [PDF] the parties that she would ignore any arguments in their attachments to their post-trial motions that were new and therefore a backdoor way of bypassing the page limits she set for them, writing that "Any argument that is not explicitly articulated within the briefing page limits will be disregarded. Any supporting documentation shall be for corroboration purposes solely and shall not be used as a vehicle for circumventing the Court's page limits."

And she meant it, it now turns out. She has given them a list of what she will not consider in her Order Striking Evidence [PDF], and it's both sides misbehaving.

So now we know why these law firms have been annoying her so much. She gives them limits, and they simply ignore them.

Also, Apple has brought a case to the court's attention, another super-plaintiff-friendly ruling from the Federal Circuit. And the parties continue to fight with the court over the issue of sealing materials. This judge isn't receptive, and while she earlier stayed her orders to unseal on the basis that she'd wait until the Federal Circuit could rule on appeals, now she denies a Samsung stay request.

And I found for you some material on what impact reexamination of a patent can have on litigation. I saw a lot of questions from you in your comments, so I researched it a bit for you.

Every year Red Hat Czech offers a list of topics for bachelor and diploma theses to students from local universities. The topics are usually suggested and posted by Red Hat employees who then work with the students as technical consultants and mentors.

We see this as a good opportunity for students to learn about open source software, communities and collaboration and for us to find potential future employees (so there’s a great motivation too). We want students not to see their diploma or bachelor thesis as some boring obligation, but rather a “fun” way to learn new things, meet people and gain experience. And last but not least they are potential contributors to the projects they are involved in.

This year I managed to get several students I’m mentoring to pick a topic related to KDE.  Although all projects are somehow related to KDE Telepathy, it’s a good start

Today I want to introduce work of first two students, Stanislav Láznička and Artur Dębski.

Makneto++

Stanislav Láznička is doing his bachelor thesis on Brno University of Technology. His topic is “Shared Board – Makneto“, more specifically, his task is to port Makneto to Telepathy. Makneto is a whiteboard-sharing application for KDE, similar to KWhiteboard. It has been written some time ago as a diploma thesis. Since then several students have based their theses on this project (not all of them successfully though). Stanislav is now researching how to use the Telepathy framework and preparing to start the actual port soon. If you are interested in further progress, follow his blog and his git repo on bitbucket.

KTp Active

Artur Dębski (IRC: mentero), a student from Silesian University of Technology in Poland. His topic is “Touch interface for KDE Telepathy“. Yes, hang on to your hat, we are going to have a totally awesome Plasma Active application for Instant Messaging. Artur has written an extensive blogpost about his work together with some mockups. You can checkout the existing code from here, there’s already a demo app to play with!

Continuing the series on KDAB contributions to Qt 5.0 (part 1, part 2, part 3), this time we cover C++11, and various optimizations

C++11 support

There have been many people and companies working on C++11 support in Qt 5. KDAB was involved in several Qt 5 features which relate to C++11. An overview of the features in Qt 5 which relate to C++11 is available from a presentation last Autumn.

One of the porting issues in a Qt 4 to 5 transition is that the QSKIP macro now takes only one argument where previously it took two. This is a source incompatibility for users to deal with. As macros can not be overloaded the way that functions can, a different solution is needed. That’s where  variadic macros become useful. If C++11 is enabled when compiling a file which uses QSKIP, the definition of that macro looks like this:

#define QSKIP(statement, ...) QSKIP_INTERNAL(statement)

The QSKIP_INTERNAL macro is the implementation of the regular QSKIP, so the C++11 version accepts any number of arguments, but silently drops all arguments except the first one.

Almost a year ago, I added a Q_DECL_OVERRIDE define corresponding to the C++11 override keyword. I also added a define for marking methods as ‘deleted’ and used it to ‘delete’ some methods which have previously only been private, and some constructors which should no longer be used in Qt 5. This makes for slightly better compiler error messages when attempting to use those methods.

With the Q_DECL_FINAL, corresponding to the C++11 final keyword, already defined in Qt 5, moc, some other internal tools and other features in Qt 5 needed to be adapted to handle it. The ‘final’ concept in Qt is somewhat complex, because aside from supporting the C++11 final keyword, the MSVC non-standard extension for ‘sealed’ classes is used in C++98 mode.

Similarly, the pre-existing Q_DECL_NOEXCEPT define gained a sibling in the Q_DECL_NOTHROW define. Although exceptions are not a central part of the Qt API and error handling model of Qt itself, it is also important to ensure that downstreams using exceptions more extensively can do so while taking advantage of C++11 features. This too enables an MSVC extension which is similar enough to the C++11 noexcept feature to be related to it. The Q_DECL_NOTHROW is defined as Q_DECL_NOEXCEPT where possible.

Something which has no C++98 equivalent is the constexpr keyword. This allows compile-time computation of certain constants. By marking the API of the Qt geometric classes as constexpr, many expressive possibilities, including calculation, open up to the programmer which were not possible before:

  constexpr QPoint twelve_twelve(12, 12);

  switch(someInt)
  {
    case QPoint(15, 15).x():
      break;
    case twelve_twelve.x():
      break;
//     case QPoint(12, 12).x(): // ### Error: Duplicate of above.
//       break;
    case (twelve_twelve + QPoint(4, 4)).x():
      break;

    // No magic number for the value being tested anymore:
    case QRect(twelve_twelve, QSize(40, 20).transposed()).bottomRight().x():
      break;
    case QLine(QPoint(4, 5), QPoint(6, 7)).translated(twelve_twelve).x2():
      break;
  }

We also added the constexpr marker to a few other locations in Qt 5, such as in QModelIndex, and some in QFlags. The full possibilities and patterns of this are still to be discovered.

Optimization in signal slot connections

With the rewrite of how signals ans slots work in Qt 5, there were suddenly mutliple implementations of what could happen when a connection is made. The natural way for C++ developers to create an abstraction for that is polymorphism and virtual methods. This works well usually, but when virtual functions are used in a class causes the compiler to have to create extra functions and data which it would not otherwise have to. In small doses, that is not a problem, but as the new connection syntax creates a lot of these objects, their unwanted price adds up. An optimization inspired by a boost feature in a similar problem domain was added by KDAB.

A follow-up patch re-enabled tail call optimization, to allow the compiler to make further optimizations in all cases.

qEnvironmentVariableIsSet and qEnvironmentVariableIsEmpty

Qt 5 sports a new way of testing for the existence of environment variables. These are a more modern (allowing the use of C++11 noexcept) and exception-safe version of the pre-existing methods for querying the environment.

QStringList::join(QChar)

Also in the domain of optimizations, a new overload of QStringList::join was added by KDAB in Qt 5. This avoids conversion of the QChar into a QString only to iterate over the QChars inside it again. Everyone gets the performance improvement for free when joining strings with a single character.

Removing use of QtAlgorithms

Several algorithms available in Qt are conceptual duplicates of what is provided in standard algorithms, such as qFind and std::find. The reasons for those algorithms to exist is partly because built-in platform support for them was not previously good enough. For Qt 5, the target platforms are modern enough that we can assume a working STL for our purposes. Unfortunately, due to some implemenation and behavioral differences, it was not possible to remove the QtAlgorithms, or to implement them in terms of the standard algorithms and gain the benefits that brings automatically.

Slowly though, we can port the implementation of Qt to use standard algorithms instead of the Qt ones. KDAB is participating in creating some patches towards this effort as it grows.

Looking past the irony that QML will be available for all platforms but WP8 in the short-term, and Nokias previous involvement in the development of QML, it is nice to see the platforms being created.

The last in the row is Ubuntu Phone, others are Jolla’s Sailfish, RIM’s BB10 Cascades, KDE’s Plasma and Nokia’s Components for Harmattan and Symbian. Qt seem to unlock the future UIs for devices.

What is striking is the interaction patterns being established. Nokia Swipe, Sailfish as well as Ubuntu Phone seems to rely heavily on swiping from the sides of the screen. This is, in my experience, the key to a truly one-handed device.

Using Android, you are constantly forced to hold the device in awkward angles or use two hands to reach the home button, be it physical or on-screen. Swiping with the thumb is always possible when using one hand (as long as you have an opposable thumbs), while the two-handed user can swipe using the index finger without feeling hindered by the interface.

From a development perspective, it is interesting to see how the different QML Components are shaped. Ubuntu seems to have some interesting ideas for theming going on, and the other platforms have their own strong points.

One interesting comparison is to look at the API for a single component. Comparing the CheckBox elements of Ubuntu Phone, BB10, Harmattan, Symbian and Plasma gives the following API (only looking at the properties and signals that I regard as relevant to the comparison in question).

Properties

• text (BB10, Symbian, Harmattan, Plasma)
• checked (BB10, Symbian, Harmattan, Ubuntu Phone, Plasma)
• enabled (BB10, Harmattan)
• pressed (Symbian, Harmattan, Ubuntu Phone, Plasma)
• hovered (Ubuntu Phone)

Signals

• onCheckedChanged (BB10, Symbian, Harmattan, Ubuntu Phone, Plasma)
• onClicked (Symbian, Harmattan, Ubuntu Phone, Plasma)
• onPressAndHold (Ubuntu Phone)

Where does this leave us? For all platforms, one can use the checked property and its onCheckedChanged signal to act. The rest is in up in the air. Ubuntu Phone seems to split the text from the checkbox while the others keep them together. The enabled property is missing from most platforms. Here, even Symbian and Harmattan, both from Nokia, seems to differ.

Still, as the concepts seems similar, the work to create a cross-platform set of components wrapping the components of each platform should not be an impossible task (looking at checkboxes only, that is). Hopefully the end result will not be a too fragmented API landscape and the involved parties will work towards a common setup of basic properties and signals.

Either way, I’m happy seeing that 2012 was a bad year, 2013 looks very exciting. Seeing all these innovative phone user interfaces being created with QtQuick, I’m happy to work at a company innovating in the automotive space using the same technology.

Disclamer! These findings are based on the API docs only. Feel free to correct me by commenting.

The Samsung 840 SSD drives have dropped enough in price that I bought one (for this year’s combined sinterxmasbirthday). Then I pulled my older AMD machine out of the storage closet and installed OpenSUSE 12.2. Which in itself isn’t much of a story, except that installing from a silent USB stick, onto a silent SSD, with a energy efficient low-power CPU and a silent fan is an eerie, creepy experience. A machine that, within the limits of my hearing and against a background of one humming hard disk in a NAS box, is totally silent while doing work — that just doen’t fit with my ideas about how machines work. Kind of like electric bicycles and cars need some kind of noisemaker to announce their presence, otherwise they are scary as well. The difference an SSD makes is amazing; those little starting-up fireflies from OpenSUSE buzz around like they’re cooked up on amphetamines and cold-start to KDE (with auto-login) is something like 15 seconds. It’s moving into my laptop, where I hope it will also have a positive effect on battery life. And for noisy working machines, I can always stick to my Core i7 with three bricks full of spinning rust; that really sounds like it’s doing some work, especially when building KDE in a FreeBSD VM.

2012 is not the best year for me in the KDE team, I almost didin’t coded, heal life issues keep me busy in a way that I couldn’t avoid. I did a few things however:

• The program that I started as an University Project back in 2008, Rocs, is now being used in universities around the world for teaching Graph Theory and Data Structures. ( Much thanks to Andreas (CoLa) and Wagner Reck ( wiglot ) for helping me on improve my initial mess into a true opensource project. If you are a teacher or computer scientist student and never heard of Rocs for Data Structures / Graph Manipulation, do a favor for yoursellf and go take a look.
• I’v spend this year much money on KDE related stuff: Bougth one kick ass Konqui Costume ( that costed around 2,200 EUR, + shipping )  and 2k buttons with konqui paintings to be used everywhere in events. It was used sucessfully in FISL and LatinoWare, the two biggest events in latin americas ( one with around 8k participants and the other with around 5k ). The konqui costume was partially sponsored by Blue Systems ( Thanks o/ ), the company that sponsor the work of Aleix Pol and other great KDE hackers.
• I’v Been into the two more importants events for KDE in the latin americas, the LaKademy and FISL, LaKademy was the one place that I hacked, tought. It was done primarely to tight the community in the latinamericas – One thing that I like very much is that the people in KDE-BR is like a family, Sandro, Aracele, Filipe, Lamarque, Wagner, Me, Camila, Henrique. We didn’t know anyone, KDE introduced us all, now we all are friends and BFF’s. <3
• I’v tried to do a internship for KDE with 6 students from one university that I have good relationship with, this experiment failed miserabily and I’ll try to do it again in the future but not in the same way that I did. The students did a few things, but at turtle paces, two quit in the first week, two did nothing for two months, while I was trying and trying to help them, they didn’t want help ( or work… ), that’s a real problem with “Free Software Groups” on universities that I’ll talk more in other post. But seriously, if you don’t want to work, don’t ask for a job. The code that they did will eventually end on KDE 4.11 ( since 4.10 passed by and they didn’t delivered. -.-’ )

This is my small resume for KDE in 2012, I hope 2013 is a better year

 

As of beginning of December I started contributing to the Mozilla community… I must say amazing people and amazing environment.

I was invited by Josh Matthews and David W. Boswell to a Mozillians meeting. The first task I took upon myself was getting new contributors mentioned with every release. With the help of the others I went around pinging people and a couple of days later we reached the consensus that we will be linking to a blog post on http://blog.mozilla.org/community/category/spotlight/ from the release note with every release.

We will be using a set of premature scripts I am working on to detect new contributors to a release as well as the contribution rate (code and bugs which is inspired by my GNOME fellow Andre Klapper). Those can be found https://github.com/seiflotfy/mozcctools (nothing special they just spit out JSON stats, will automate them this weekend).

And last but not least. After an interesting call with the super dad himself, Mike Hoye, I took a challenge upon myself to hack a tool that does the following:

Enter a a keyword, and it will spit out Mozillians that are affiliated with this keyword based on their code commits and bug reports.

It took me around 60 minutes to hack the tool using Zeitgeist and the Full Text Indexer extension. Basically importing the last 120k code commits and indexing the commit message. I will publish the code soon. After that I spent 30 minutes with Josh and Mike playing with it testing the results. Mike Hoye has some great ideas on how to deploy such a tool (Bugzilla included), and hopefully I can show off the cleaned up code in the following days.

I am thinking of deploying such a tool for the KDE and GNOME community sites to find ways to directly contact hackers based on keywords.

All in all the Mozilla contribution experience is really fun, and while not hacking on Firefox or B2G I am having fun developing tools for enabling the community.

So after 4 years of development Zeitgeist is reaching 1.0. The Zeitgeist team has reached a big goal/milestone

What’s new?

1. New libzeitgeist2: instead of libzeitgeist which was developed and hosted on Launchpad now reuse and expose our own internal Vala components. When comparing libzeitgeist2 to libzeitgeist we can see over 65% less code (thanks to Vala) with 90% compatibilty with libzeitgeist. (libqzeitgeist not affected)
2. GObject Introspection support
3. Faster performance
   • Testing with 100k events DB here are some plots, those are peromances of synapse and standard time based queries where the yellow bars are 0.9.5 release and green bars represent “master”. Shorter bars are better.
4. Smaller DB size: With a very small modification to the main table (primary keys), SQlite created some automatic indices that cover what we need so now instead of 34 indices we only need 25.
5. Lots of bug fixes

What now?

Well if you want to help out roll out this release. We could use some packaging, testing and porting of apps. We won’t be able to release until the latest Vala has been released due to some bug fixes concerning the gir generator. But all in all it looks like an exciting release.

KR49 now holds KDE SC 4.9.5 packages. Thanks to the packagers involved! You can report issues on the opensuse-kde mailinglist or on IRC in the #opensuse-kde channel.

The latter is also where the next openSUSE KDE team meeting will take place, on Tuesday 8 January 18:30 UTC (19:30 CET).

2012, a great year for KDE
2012 has been an important year for KDE from many perspectives. KDE e.V. turned 15 years old, Nokia finally quit Qt and a new ecosystem lead by Digia is laying on KDE to get mature. We have published our Manifesto, that is the result of long internal and very interesting conversations (I wouldn't call them discussions) about who we are, how did we get here and what we want. ALERT, out first experience in EU R&D projects, is now a reality. KDE has broken every record in the GSoC program, our KDE 4 series is getting mature and attention is coming back little by little to our software since users are understanding that we are delivering what we promised. Plasma is way more than a crazy idea and now many people perceive how powerful can be, not in a few years, but in a few months.
Applications like Krita, Calligra, Dolphin, etc. are getting more and more popular and others, that lost track in the past, like Kontact, are recovering the favor of many users since improvements and better integration with Akonadi and Nepomuk (semantic desktop), are becoming obvious. We feel that more and more people recognize us as a key member of the Free Software ecosystem, not just for our software, but also for our commitment with freedom and our well desired reputation as serious and stable organization.
Financial situation
2012 has been the year in which Nokia showed us once again that corporations can become your best allies, but also that their commitment with freedom and specific technologies are strong only as far as they are compatible with their strategy, which  can vary quiet fast. Once again, KDE has shown others that strong principles are a great base for not just surviving, but digesting changes.
Our economic model, like many other FLOSS community projects, was based on the support of big corporations that invested in us as R&D environments (they were interested in our technologies), as cheap talent ecosystems (recruiting well formed young developers) and as branding feeders (investing in community projects has positive effects in company reputation).
But that support to upstream project, specially to desktops, from big corporations, has been reduced the last few years for different reasons. We are not the next year big thing in the desktop/mobile space anymore and that have a reflection in our financial situation. Many of those who have supported us in the past, link success to market share. That has never been our battle but, we did very little to fight against that wave. It was profitable.
So our past economic model, is drained and we need to adapt ourselves to a new field in which SMB (Small and Medium size Business) and individual support must become more relevant. Since previous Boards made a good job, we can face today those challenges with little risk, in financial terms, taking the required time to make the internal changes that, if we do them right, will define our future in this area the following five years. As simple as that.
This model change will take some time. This 2012 we have taken relevant decisions and some more are coming in 2013. Results must become clear in 2014. This is a very tough sector and it is very risky to make plans, but I have faith in the path initiated in 2012. Many Free Software projects around us are growing like hell. We have to catch up a little, yes, but we have been here long enough to understand that running is not always the fastest way to get to the finish line... and frequently not the healthiest.
2013 goals
Our major goal for 2013 is to get take more steps toward sustainability, in a very volatile environment.
How do we want to achieve this from the financial perspective?
There are two main work lines:

1. Reducing our exposure to market changes.
2. Becoming a more flexible organization.

In this journey, we will need everybody's support. As a technical community, finances haven't been a priority for our members. This do not have to change in the future since KDE e.V. is here to support KDE community. Just a little more collective focus will be needed. More communication effort from our side, as Board/Organization, and from those involved in this area, will speed up the process. We are already working on it.
I feel lucky of playing a key role in KDE these days. I am having fun and I am optimistic about our future in the financial area. If during 2013 we confirm the switch we began this year, we will have a good platform for growing healthy and strong the following years.
How can you help us?
If you are a KDE community member, please consider joining KDE e.V. If you are simply a KDE user or fan, you can get involved in our project as contributor or, if you do not have time to invest, please consider supporting us economically through our Join the Game program. KDE financial activity is summarized in our Quarterly Reports, you can download in .pdf format.  Agustin Benito Bethencourt (Toscalix) KDE eV and KDE Spain member Spanish Blog: http://abenitobethencourt.blogspot.com Linkedin profile: http://es.linkedin.com/in/toscalix

Continuing the series on KDAB contributions to Qt 5.0 (part 1, part 2), this time we cover itemmmodels, effective C++ and janitorial work.

Itemmodels Improvements

As KDAB took on the role of Itemviews Maintainer in Qt 5, naturally we were the primary contributor and reviewer of all itemmodels and itemviews patches.

Several relevant changes have been made in Qt 5. To start with code location, some classes have been moved around to different Qt modules, making them more useful to non-widget applications. In Qt 4 times, the QAbstractProxyModel, QSortFilterProxyModel, QIdentityProxyModel, QStringListModel and QItemSelectionModel were in QtGui. Now they have been moved to QtCore. Similarly, the QStandardItemModel remains in the QtGui module in Qt 5, but most other itemviews related code, including the QDirModel and QFileSystemModel, was moved to the QtWidgets module. The QProxyModel class, obsolete since Qt 4.1 or so, was entirely removed, and a copy was placed in the UI Helpers repository for those who want to use it.

Some APIs were also marked as virtual in Qt 5. For example, QAbstractItemModel::supportedDragActions was made virtual, and setSupportedDragOptions was deprecated. The idea for this change came in 2009 when I first read the Advanced Qt book, which recommends overriding the supportedDragActions method, despite it not being virtual. The snippet happens to work because supportedDropActions (which is virtual) is actually overridden, and because of how the two concepts interact with each other. In Qt 5, the code has been changed to match the expectations of the book . The QAbstractItemModel::roleNames method has also been made virtual, for consistency with the rest of the QAbstractItemModel access API.

The QAbstractItemModel::sibling method was made virtual too, but for separate reasoning. The default implementation of sibling() is to get the parent QModelIndex, and then get a particular child of that parent. Calculating QModelIndexes, particularly for the parent() and particularly if there are proxy models involved, can be expensive. A concrete implementation of a model typically has a way to get a sibling index more efficiently, and now that it is virtual, that can be used. The sibling method is now also reimplemented in QSortFilterProxyModel and QIdentityProxyModel to take advantage of this.

Also on the subject of optimizations in itemmodels, the dataChanged and layoutChange signals have gained new parameters to be more expressive about how a model or its data changes when it does. Specifically, the dataChanged signal now has an optional QVector<int> to specify which roles have actually changed. This means for example that QML can be more efficient and effective in what bindings it updates when a model changes data.

The layout change signals were also extended with optional hints to allow the developer to be more specific about what, exactly, is changing. It is now possible to specify a list of parent QModelIndexes whose children are being relayouted. This is useful if you have a deep tree model, but only sort one section of it. It is also now possible in Qt 5 to specify what kind of change is happening. For example, the data may be sorted, or rows may be moved around to different locations in the tree. Together, these new APIs can allow for speed improvements of over 98% in cases of very wide table models and other large structures.

One of the confusing parts of the Qt 4 API was that the QModelIndex::internalId returned a qint64, but QAbstractItemModel::createIndex overloads only accept a quint32 (Note difference in size and in signedness). One of the reasons that is hard to solve is that making the internalId has always been stored as a void*. trying to store a quin64 in that would result in loss of data on a 32 bit system. Changing the data storage to quint64 would be inefficient on 32 bit systems. To solve that, all of the API has been normalized to use quintptr, meaning that it is a int type the same size as the size of a void pointer. This also had the effect of making the QModelIndex API more compatible with the C++11 constexpr keyword.

QModelIndex is now also a built-in metatype in Qt 5, so using Q_DECLARE_METATYPE(QModelIndex), or qRegisterMetaType<QModelIndex>() is never needed anymore.

The default value of whether a QSortFilterProxyModel sorts dynamically (dynamicSortFilter) has been changed from false to true. In Qt 4 times, this is a constant source of bugs when people (myself included) forget to set it to true, even though that is what most people want.

We have made many other bug fixes, performance enhancements and other changes to the itemmodels APIs. The number of unevaluated itemviews bugs is ever decreasing, and new bugs are quickly evaluated.

More effective C++

Qt 5.0.0 has been an opportunity to make changes which were not possible in Qt 4 releases, mostly due to binary compatibility concerns. These changes included marking methods as const where they can and should be, and marking constructors as explicit where possible. In terms of C++98, the explicit keyword is usually only needed for types which can be created with only one argument. For example, imagine there was no explicit keyword used in the QObject constructor, and consider this code:

QObject someObject = new QObject;

Do you see the bug? A QObject pointer is assigned to a local non-pointer QObject. If there is no explicit keyword used, then a compiler will ‘helpfully’ try to perform an implicit conversino and call a constructor which takes only one argument if the types match. So the above would be treated the same way as:

QObject *parent = new QObject;
QObject someObject(parent);

This is usually not what the programmer intended. Use of the explicit keyword helps the compiler find bugs like that, so we’ve added it where it was missing before.

The situation is a little bit more complex with C++11, because now brace-initialization can be used to cause implicit conversion for more than one constructor argument. This could have unintended consequences, but is probably less likely today. Nevertheless, some instances of it have been marked as explicit too.

For exception safety and speed, many copy operations in Qt were changed to use the copy-swap idiom. This also required adding member-swap to more of the classes in Qt 5.

Janitorial work

So many things changed in Qt 5 compared to Qt 4, that there was a lot of clean-up to do. This is the kind of work that is not very exciting, but still has to be done in order to maintain a clean codebase. For example, KDAB wrote patches removing some symbian support code (no longer supported in Qt 5), QWS code (made obsolete by QPA plugins), and other long-obsolete or deprecated methods and classes.

We also worked on documentation clean-ups requires as part of modularisation, and as part of keeping the documentation up to date with the code, compile fixes when certain features are removed (eg QT_NO_CLIPBOARD) and replacing some use of Q_WS_* defines (Q_WS_WIN, Q_WS_X11 etc).

The Q_WS_* defines are obsolete and those macros are never defined. In some cases the code within them needs to be changed to operating-system specific (using a Q_OS_* define), and in some cases, it needs to be changed to a runtime check, if it really does relate to the window system only. This work is not complete. There is still a lot of code in Qt 5 which is wrapped in Q_WS_ defines, and is therefore effectively commented out.

Ah, new years. A time of (sometimes planned) changes. Inge, I hope your hand gets better, or whatever it is. Me, I’ve resolved to quit being such a wuss with respect to git and actually use it a bit, and so after a long absence put something into the KDE source repositories again. I’ve contacted some maintainers for a little guidance. David’s post from two months back is going to help, too, since SVN fits in my brain (as do some distributed VCSses, but not git so far — not without violence).

The last time we looked in on the Microsoft v. Motorola litigation in Seattle, the judge, the Honorable James L. Robart, had just ruled that Motorola would have no right to injunctive relief in the US and Germany for its H.264 and 802.11 standard essential patent portfolios, at least not in the current set of facts, although he allowed that facts could change in the future.

The judge has asked [PDF] the parties to give him more information about Google's license agreement with the MPEG-LA patent pool, and he set a hearing for oral argument for January 28 at 1:30 PM in Seattle on that issue and on a Microsoft motion for summary judgment on invalidity. If any of you can attend, that'd be wonderful.

We now can have a much clearer picture of the parties' positions, now that we have both parties' post-trial briefs on the subject of Google's license agreement with MPEG-LA regarding H.264/AVC patent pool.

The crux of the debate is how to interpret one clause in the agreement, Section 8.3. Does it require Google to grant Microsoft a license to Motorola's H.264-essential patents? Microsoft says it does, and Google says it does not. Google says it chose a license whereby it would have to list all affiliates it wished to be covered by the agreement, and to date it has not listed Motorola. It didn't close on the Motorola deal until after it entered the license agreement with MPEG-LA anyway. And Motorola never on its own put any of its relevant patents into the MPEG-LA patent pool. So either way, Microsoft has no rights to a license via the MPEG-LA patent pool, Google argues, only by negotiated agreement under normal RAND terms, obviously at a higher rate.

After more than 4 months of finishing and fine-tuning, my Google Summer of Code work for KStars is now merge worthy. An hour ago, I merged the gsoc2012-spacetime branch to master.

While I am certainly delighted that my work is finally merged I am watchful of any bugs that might have crept in. But I can now continue contributing knowing all that work did not go to waste!

This took a really long time, but the community kept me going (specially Akarsh & Rafal). Thank You!

Happy New Year KDE! :)

If you’ve watched Neverendingo’s awesome video you will have seen how the activity on UserBase suddenly ran wild, when the Translate extension came into being.  We regularly get new translators registering on UserBase, and more recently translators for TechBase are signing up.  It’s clear that we have a dedicated core of translators, but beyond that we had no indication of other activity.  With this in mind, I set out to investigate.

Unable to display PDF
Click here to download

 

So, what do we learn from that?

• A few dedicated people have translated a considerable number of pages to a very high degree.  Bear in mind that there is no indication of how long any translator has been working.  There is at least one example of a fairly new translator that has done a great deal of work in a short time.
• There are a surprising number of pages translated to between 31% and 79%.
• It appears that some translators work hard on a few pages only, maybe for a particular project.
• Sadly, there are a few people that sign up, often for one of the less well-known languages, but do little or no translating.

It should also be noted that LTR (left-to-right) languages have not been well supported in Mediawiki, although there is some progress with this, which goes some way to explain lack of pages in those languages.

And what of TechBase?

Translation on TechBase is much newer.  It’s not always relevant to translate pages, particularly if they are written for use by a small, one-language team.  It’s encouraging, though, to see regular contributions to translations.  Here are the statistics for TechBase:

Unable to display PDF
Click here to download

So finally, I want to thank everyone for this tremendous effort, and let’s make 2013 even greater!

And don’t forget - 

 

After years of hard work by Simon team, Simon 0.4.0 is out which is the major release after a long time.

This new version of the open source speech recognition system Simon features a whole new recognition layer, context-awareness for improved accuracy and performance, a dialog system able to hold whole conversations with the user and more.

You can read about the new release in detail here.

It feels amazing when something you have implemented during Google Summer of code 2012 is part of the release. Also, this was the first time i was part of any release

I know, it is very late for posting about my experience during GSoC 2012 but i do not want to miss this opportunity to share it with you all before this year ends.

GSoC 2012 package

 

Let me brief you again with my project, it is based on Multimodal Accessibility in which i am using Computer Vision to improve Speech Recognition in Simon. As the major obstacle for command and control speech recognition systems was to differentiate commands from background noise, so in my project i am using the computer vision to determines when to activate / deactivate the sound recognition using visual cues like when the user is actively looking at the screen/robot and is speaking something.

Why i picked up this project in particular?

I came to know about GSoC from our seniors and the learning experiences they got out of it really motivated me to get into this. So i started searching for projects before the organisation list was even announced. Fortunately, i saw this project idea and i really liked the idea. Also, I was working on face detection lately. I also knew from seniors that the KDE is awesome community and Computer vision is one of my favourite fields. I love to work on something which replaces the normal way of using computers and which replaces physical mouse/keyboard. This all factors together droved me completely towards this project and kept me motivated. So i contacted Peter and we discussed about the ideas and it was the first time i stepped onto IRC Then i kept discussing about it on the irc and the mailing list and that’s how it all started

Experience

It has been an incredible learning experience and I’m very happy of the final results. I am more positive and confident than ever. I learnt a lot of basic stuffs like git, makefiles, building, executing and debugging code and much more. This project also acted as a starting point to my contribution to the open source community. It was my first “serious” project with such a big codebase but Simon is nicely documented and with peter’s proper guidance, i was able to adjust very soon.

I also faced many challenges during the period. It was really tough to adhere to the timeline. CMake build system and git was very much new to me. There were many unexpected bugs which surprised me a lot but then it was so much fun figuring it out and fixing it. Also working on UI was time-consuming.

KDE also invited and sponsored me to the Tallinn, Estonia for Akademy 2012 which is their annual conference. It was my first international journey. It gave me opportunity to meet people in real whom i just knew from the irc nick. The opportunity to interact and share thoughts with highly intelligent and experienced minds was a life changing experience, and the biggest takeaway, which would not have been possible without the support of Google, KDE and my mentor.

I also participated in Randa meeting 2012 in Switzerland as a part of KDE Accessibility team. It was my first sprint ever and was really very productive. I implemented vision configuration and solved many bugs there. I would again like to thanks Mario Fux for organizing this fantastic event and all sponsors and donors who made it possible.

End Result

Peter has recorded great video on Context awareness which covers most of the things i have implemented during GSoC 2012.

Simon 0.4.0: Context awareness

As you can see clearly in the video, that Simon has turned into multimodel speech recognition system. Simon will deactivate the input devices in absence of the user. This is strikingly similar to the day-to-day communication between humans!

Acknowledgement:

I owe a big part of success to my mentor Peter Grasch for always being there to answer my questions, offer advice and review the code. I have learnt a lot from him and I am sure I have improved a lot as a programmer. The best thing about working with him was that he never really disclosed the solution, instead he gently guided towards the direction of the solution, so I never lost a learning opportunity

Randa Meeting 2012 with Peter Grasch

 

I would also like to thanks Aditya bhatt, Aakriti Gupta and Nikhil Marathe for giving me amazing start and guiding me throughout the year.

And thanks to lots of other people in the community as well whose names I am forgetting. While there I would like to thank my friends keeping up with me when I slept during the day and worked at night.

And more than anything else, I am very happy to make my parents proud after so many years of constant hard work they have put and sacrifices they have made to to chase my dream of becoming a computer engineer. I hope it’s the first of many more proud moments that I will be giving to them in the future.

What’s Next?

I would like to maintain this project after GSoC and continue contributing myself to Simon/KDE. So stay tuned, there is much more to come

To Future GSoC Aspirants:

I would suggest maintaining good communication links with the comunity and trying to be involved with the project as much as possible.

Peter adviced me to first draw the class diagrams before starting my project and it really helped me in the future. I know we all have habit to directly start with coding but i would highly recommend you to have proper structure diagram ready before starting to code, it will give you clear idea about the implementation.

Try to budget a lot of extra time in your project application – most of us are not experienced developers and cannot estimate the amount of work needed for something correctly. Plus, when some additional problems arise (and they will), it’s always better to have time set aside to deal with them. I would highly recommend you to discuss this with your mentor before submitting your proposal.

Finally, Nothing is too hard to accomplish if you love what you do.

Ever since sigetch created a smooth inking pen for Gimp Painter, artists have been asking us to implement something similar in Krita. It's a feature particularly in demand for inking comics, and since comics is one of Krita's focus areas...

It basicaly works by looking at the history of the stroke -- the last twenty or fifty of positions or so, the speed with which you paint and then calculates a new position, one that makes the line smoother. I don't pretend to understand the mathematics -- but it was pretty easy to figure out from Alexia Death's clean and clear implementation in Gimp 2.8, so I took that as a model. Free software rocks more!

I actually couldn't believe it when I was done, and Timothee Giet reported that it worked as per spec... But here's a sketch from his hand that proves it!

In a few hours 2012 ends and 2013 begins. So it is a good opportunity to recap and look back what happend in the past 12 month in the ownCloud world. I must say that is was an awesome year where a lot of things happened that are worth mentioning. A huge thank you to everybody in the ownCloud community and my coworkers at ownCloud Inc. which made all this possible.

The things that I specifically want to mention are:

KDE
The first significant thing of 2012 for me was the departure of the ownCloud project from KDE. This was the result of an intense discussion in KDE about the role of ownCloud in KDE, the requirements to be a KDE project and my role. I stepped down as a KDE e.V. board member and treasurer as a result and ownCloud is now an independent free software project. I still find the outcome a bit sad and not optimal for both communities but on the other hand sometimes a fresh start is good and needed. ownCloud participated in this years Google Summer of Code and Google Code-in together with KDE so there is still a lot of collaboration happening where it makes sense. All the best to KDE and thank you to my friends there.


The community
The ownCloud community grow dramatically in the last year. It's a bit difficult to measure as we don't collect real community metrics yet. But just a brief look at the number of post to the mailing-list, the activity in our bug-tracker, the number of commits, the number of contributors and the number of downloads show a very significant increase. I'm super happy that we have such a healthy volunteer community. If you found a company around an free software community projects there is sometimes the effect that the company consumes the community by employing all the community people. Luckily the free software community is growing even faster than our company so this works perfectly.
The ownCloud community has volunteers in all important areas like PHP development, Qt desktop development, iOS development, Android development, packaging, testing, security, design and UX, events and PR. Thanks to all of you who contributed.


Developer meetings
In 2012 we had 2 big developer meetings. The first one was hosted in our Stuttgart office in April with about 18 contributors. A lot of new people came and joined the community and it was the biggest meeting so far. We couldn't fit more people into the room as you can see at the pictures here: http://blog.karlitschek.de/2012/04/what-weekend.html so we had to look for a new location for the next meeting. Luckily for the fall meeting KDAB hosted us in Berlin and the University of Michigan in Ann Arbor hosted a second meeting at the same time in the US. Over 30 developer attended and it was a blast. Thanks to our hosts and everybody who joined. Let's see what we do next year if we grow even bigger.


Releases
We had several great releases in 2012.
First of all we released ownCloud 3 in January, ownCloud 4 in May and ownCloud 4.5 in October. But additionally we also released our iOS and Android clients which are constantly improved and we also released the ownCloud Desktop clients for Mac, Windows and Linux.
I don't want to list all the features here but I can say that I'm super impressed by the new features the ownCloud community developed in just 12 month. I also have to confess that not every feature is as stable and bug-free as I wished. Because of that we have to concentrate more on stability and quality in the future. More about this later.
I'm especially happy about the integration with KDE and GNOME which are both already quite advanced and it's awesome that ownCloud is now packaged for all major Linux distributions and available as virtual appliances.


Development process
One year ago we had a relatively unstructured development process on gitorious.org. We wanted to focus more on quality so we introduced several processes over the last few month. We have a Jenkins server for continuous integration testing. People are working on unit tests, acceptance testing, integration testing and other things. We moved from gitorious.org to github which gave us a lot of new features for better collaborative coding and it is very successful so far. We moved from our own hosted TheBugGenie bug-tracker to the github one which is really nice because of the integration of coding, bug fixing and feature request tracking.
At our last developer meeting in Berlin we decided to introduce peer reviews for all commits that go into the ownCloud core repository and we use pull requests for that. It makes development sometimes a bit slower but you can already see the impact on quality. We are getting way better here. Of course we have to make sure that contributing to ownCloud is not more complicated as needed but I think we found a good middle ground here.


Company
I'm involved in free software for over 15 years and I think that a truly open and community driven development process, like for example in KDE, is the most effective technique to create great software and innovation. But it's also clear that communities don't work very effective in areas like QA or structured product planing where companies are better. So I always wanted to try to combine the best of both worlds. See also my blog post here for more thoughts or my chapter about open source business models in the Open-Advise book. ownCloud Inc. became fully functional at the beginning of 2012 and I must say that it works great together with the community. The community and the company are able to push ownCloud forward together in a very effective way. ownCloud Inc. employs now 35 people and closed it's second financing round this fall. We at ownCloud Inc. have already several well known customers that use ownCloud. Unfortunately we are not allowed yet to name them publicly but this will hopefully change very very soon. So this is very exiting.


Talks and booth
I'm happy that I had the opportunity to gave several talks in 2012. I presented ownCloud at LinuxCon in San Diego, at the Campus Party in Berlin, the Heidelberger Innovationsforum, the Tizen Conference in San Francisco, SIGINT in Cologne and LinuxTag in Berlin where we also had a community and a company booth. In october I had the opportunity to give a keynote at Latinoware in Brazil where I presented the User Data Manifesto.


The User Data Manifesto
This is a very important topic because it describes why ownCloud is so important to me. Running free software on your PC is not enough anymore to give you control over your data and garantee freedom and free speach. A free cloud service software like ownCloud is needed. I don't have to repeat the thinking behind that because I described it already well in this blog post This is the reason why I started ownCloud in the first place and what keeps me, and I think most of the community, motivated.


2013?
So I think 2012 was a great year but what are the challenges and plans for 2013? One of the biggest challenges is to keep on moving forward with the same speed. This is more difficult as you might think because a growing community and a growing user-base can slow you down if you do it wrong. Another important thing for next year is that we have to focus more on stability and quality. But we also have to develop innovative new features so that we can lead the market instead of just copying the features of proprietary competitors as other free software projects do. The IT, PC and cloud market is moving fast forward and standing still means loosing.

I think ownCloud is a very welcoming community so if you want to participate then join our mailinglist, IRC channel or help to improve ownCloud or write a 3rd party app for it.


Thanks to everybody who contributed. Let's make a difference together.

After years of hard work, the Simon team is proud to announce the new major release: Simon 0.4.0.

New in Simon 0.4This new version of the open source speech recognition system Simon features a whole new recognition layer, context-awareness for improved accuracy and performance, a dialog system able to hold whole conversations with the user and more.
Revisiting UsabilityA lot of work has gone into making Simon easier to use - both for existing and new users.Perhaps most visibly, the main window of Simon has been reorganized to bring the most important options together in one screen.Simon 0.4.0: Main window
Moreover, the newly introduced Simon base model format (.sbm) and the integration of a GHNS online repository of base models have removed the last big hurdle of the initial configuration.
One can now easily go from a fresh installation to a working setup in less than 5 minutes without any preparation. Don't believe me? Check out the quick start below!


Simon 0.4.0: Quick Start

Many other, smaller changes sum up to one simple but important difference: Simon will overall require less user interaction while achieving more.
SPHINXOne of the major internal changes of Simon 0.4 is of course the included support for the BSD licensed CMU SPHINX. While we still also maintain full support for HTK and Julius, new models compiled with Simon will default to the SPHINX backend and the (proprietary) HTK is no longer required to build user-generated models.
Best of all: Simon will select the correct backend for your configuration transparently and automatically.

VoxforgeA major problem of open source speech recognition has always been the lack of freely available high quality speech models.

The Voxforge project has been working for years towards GPL acoustic models for a variety of languages. While their models are certainly not yet perfect, they offer a promising starting point.
The English Voxforge model is of course available as a Simon base model and can be downloaded and imported with Simon.

Additionally, starting with Simon 0.4, users will also have the option to contribute their gathered Simon training samples directly to the Voxforge server.
These recordings will then be used to train and improve the general acoustic models.


Simon 0.4.0: Training

By the way: Behind the scenes this upload is based on SSC.
ContextThere is a simple rule of thumb in speech recognition: The smaller the application domain, the better the recognition accuracy. This was always one of the core principles of Simon.

In Simon 0.4, however, we went one step further: Simon can now re-configure itself on-the-fly as the current situation changes. Through so called "context conditions" Simon 0.4 can automatically activate and deactivate selected scenarios, microphones and even parts of your training corpus.

For example: Why listen for "Close tab" when your browser isn't even open? Or why listen for anything at all when you're actually in the next room listening to music? Yes, Simon is watching you.

Simon 0.4.0: Context awareness

Dialog SystemSimon 0.4.0 also ships with the new dialog system featuring scripted variables (Javascript), integration with Plasma data engines, a templating system and - of course - text-to-speech output.

SimonoidFor users of KDE's plasma workspace, we now provide the "Simonoid" plasmoid to start and monitor Simon - including the current recording volume.
Simonoid
The screenshot above shows two instances of the plasmoid: One added to the panel and another one to the desktop.

... and everything elsePlease don't be foold to think that the above is a complete list of all improvements. For example, we also have a new sample review tool called Afaras, integration with the Sequitur grapheme to phoneme framework, an Akonadi command plugin and many, many other noteworthy changes.
You'll have to try out Simon to see for yourself!
DownloadTo install Simon 0.4.0, you can either compile the official source tarball, install a binary package provider by our Linux distribution or use the installer for Windows.


Microsoft Windows: Installer
Source Code
If you are a packager and would like to package Simon 0.4, please do get in touch with us. Thank you.