Contributors

Qt Contributors’ Summit 2014 – Save the date

Published Tuesday February 25th, 2014 | by

We are happy to announce that the Qt Contributors’ Summit will be held in Berlin on June 10-11.

The Summit will loosely follow an un-conference format, where participants can plan the schedule by themselves.

As before, the Summit is an invitation only event. The link for registering your interest for an invitation will be posted to this blog soon, as well as more details on the event itself.

Please follow the blog closely.

1 Comment


Posted in Contributors, News

Qt Contributors Summit 2013 – Please register

Published Tuesday May 14th, 2013 | by

Guggenheim mirror balls
Guggenheim mirror balls

Registration for the Qt Contributors Summit 2013 is now open.

Before going into details, I’ve added a photo of the The Guggenheim mirror balls right outside the famous Guggenheim Museum in Bilbao. It can symbolise how every Qt contributor is linked together, working on the same project, using the summit to reflect on how Qt can be developed even better. Ok, Knut, snap out of it. Over to the practicalities.

Qt Contributors Summit 2013 registration is easy. Just use the Qt CS registration form.

Since the Qt Contributors Summit is an invitation-only event, please make sure you fit into one or more of the following before registering:

  • You are a Qt Project maintainer
  • You are a Qt Project approver
  • You took part in the previous Summit (Attendees at Qt CS 2012)
  • You took a sponsorship package including event invitations (coming soon)
  • You are in the organization team.
  • You are invited by a maintainer or the organization team and we still have seats left.
  • KDE Akademy contributor

Please add sessions unconference style

Since the main idea for the Qt CS is to let developers meet and make solutions, now is the time to pre-schedule sessions on the Qt CS program wiki. Please press “Join group” at the top of the wiki-page. We will  give you wiki-access as soon as possible and add you to the group.

13 Comments


Posted in Community, Contributors, KDE

Qt-project.org under Open Governance

Published Thursday April 18th, 2013 | by

Right before Qt Developer Days in Berlin, November 2012, we began discussing with the qt-project.org moderators how to bring rest of the Qt Project into Open Governance. This includes the content management system, forums, wikis and so on – everything run as a real community-driven project, as the Qt development itself has been run since October 2011.

Open Governance structure

This figure shows the different roles in the Open Governance structure. A detailed explanation is found on the Web Open Governance page[1].

To make a proper plan, we’ve been running a series of structured IRC meetings, open for all, starting in December last year, continuing through February this year. As the meeting summaries show[2], we started the planning sessions with a discussion on the purpose of the Qt Project Web. Then we continued with discussion and investigation on how maintenance can be done, including co-development of the web content management system. Technical issues, such as improvement with single sign-on and improvements to the wiki-system were discussed. Privacy, internationalization and license issues have also been looked at.

Here are some key topics and actions crystallizing out of these meetings:

  • Single sign-on and a wiki which handles merges (not losing work) Enabling system rights for developing, testing and rolling out new features, including maintenance has to be established.
  • From a roles perspective: several new roles with extended rights are needed, especially giving more access to different admin rights as group management and access to specific web pages.
  • From a process perspective: lazy approval, task prioritization and a conflict resolution board, if needed, in case of (hopefully very few) unresolved conflicts.
  • Also the licensing issue was raised, making the Qt Project Web user agreement clearer, also including licensing to maintain privacy when doing system administration, testing, and development tasks on the site.

Next steps

We are now working on four parallel activities to make Open Governance happen.

  • For CMS development, we are on our way to implement a three-stage infrastructure with a development server and a staging server before production. Today, this is a two-stage setup. We want three stages, which allows the OS to be more flexible in doing the development.
  • We are working at implementing a new access-rights model to allow access to different parts of the CMS.
  • We have identified the need for a “system admin” agreement which is needed before granting extended group admin rights and giving access to fully developed new features, including editing web pages on the site. This agreement is designed to respect privacy laws and simplify the implementation of the planned staged development setup.
  • It seems like the biggest obstacle in the current system is the wiki lacking support for merges when co-writing. Also the single sign on has been identified as one of the key features requested. Given our limited resources, it might be best if these features were to be actively co-developed with Digia together with the community.

There are a couple of other things currently being worked on, such as cleaning up the CSS, simplifying the site navigation, removing old links, and a walk through of the old bugs in the bug-tracker. This work is currently under way.

Since these processes are being run in parallel with the upkeep and maintenance of qt-project.org site from day to day, it’s a little difficult to give an exact time span on when each step will be implemented. We will give progress updates on the Qt Project malinglist[3].

Please have a look at the references below for more information. We welcome your feedback.

1. http://qt-project.org/wiki/Qt_Project_Web_Open_Governance
2. http://qt-project.org/wiki/Qt_Project_Web_Meeting_Summary
3. http://lists.qt-project.org/mailman/listinfo/web

2 Comments


Posted in Background, Community, Contributors, cross-platform, Open Governance

Call for Sponsors | 2013 Qt Contributors Summit

Published Wednesday March 13th, 2013 | by

Qt Contributors' Summit. Photo: Alexandra Leisse

This is the 3rd annual Qt Contributors Summit and it will be the biggest summit to date due to our joined forces with the KDE Akademy conference. More than 500 contributors are expected and it’s solely dependent on sponsorship to succeed.

This will foster interaction, knowledge transfer and technical progress in a highly-productive atmosphere where new and veteran contributors can meet to influence the future direction of Qt. The key benefits of sponsoring the joint Qt CS and KDE Akademy conference are:

  • Meeting key Qt and KDE contributors. There will be 500 upstream and downstream developers and key maintainers, making Qt the top-ranked cross platform framework in developer satisfaction[1].
  • Influence how Qt will be developed in the future. Besides the Qt community, there will be many other free software projects and businesses participating in the joint Qt Contributor Summit and KDE Akademy conference.
  • Be visible. A sponsorship gives you valuable promotional possibilities such as visible advertising, prominent talks and international press coverage.

Digia is a confirmed top platinum sponsor of this year’s combined event and we need even more sponsors to make sure that this year’s event is successful.

Sponsorship Options

This year’s event is providing individuals and companies two ways to sponsor – both which come with many valuable promo benefits:

  1. Single sponsorship: Qt Contributors Summit, 15-16 July
  2. Joint event sponsorship: Qt Contributors Summit and KDE Akademy, 13-19 July

For the Qt Contributor Summit, the sponsorship packages range from Small to XL where sponsors are able to showcase their Qt commitment in front of a knowledgeable, enthusiastic and motivated ecosystem via a variety of sponsor benefits solidifying their stance as active contributors and advocates of the Qt technology.

  1. The single Qt CS sponsorship packages and the combined Qt CS and KDE Akademy sponsorship packages in detail

Practical information

Please contact Knut Yrvin at Digia, Qt or Claudia Rauch at KDE, if you would like to receive more information on sponsorship of the Qt Contributors Summit and/or the KDE Akademy conference. Please contact us by this e-mail form.

1. The report: Cross Platform Tools 2012 by VisionMobile surveying 2,400 developers.

Comments Off


Posted in Community, Contributors, Customers, growth, KDE, Open Governance

Qt Contributors’ Summit Joins Forces with KDE Akademy – July 2013

Published Thursday February 14th, 2013 | by

Just after Digia acquired Qt from Nokia, the KDE community suggested to run the Qt Contributors’ Summit together (Qt CS) with the KDE Akademy conference in Bilbao July 15-16 this summer. The conference will be at the Engineering School of Euskal Herriko Unibertsitatea (EHU; The University of the Basque Country) in Bilbao.

Picture Wall from Qt Contrubutors Day in San Francisco

Lars Knoll, the Qt Chief Maintainer & Digia, Qt  CTO says: “I’m really pleased that we can co-organize Qt Contributors’ Summit with the annual KDE Akademy conference this year in Bilbao, Spain. By close co-operation we are combining community and professionals forces to make both Qt and KDE even better”

More than 500 upstream and downstream developers will participate in this combined event which starts July 13 for both KDE and Qt contributors, and ends July 19. This includes key maintainers of both Qt and KDE projects, and top contributors. It will cover many areas of computing, ranging from core library functionality in Qt and KDE to popular user applications used by hundreds of millions of users, integrated with cloud services. All this in a highly productive atmosphere where we combine forces, exchange knowledge, and meet new contributors.

By co-hosting, KDE and the Qt Project will increase their existing Open Governance collaboration even further. Holding their annual conferences at the same time and the same place will foster interaction, knowledge transfer and technical progress. This in Bilbao, which is the beautiful capital of the province of Biscay in the Basque Country, Spain. The Engineering School and the Bilbao city are putting their forces together helping us in the community to be a great conference and contributors summit in 2013.

The entire budget of this event is funded by sponsors. Even if many are doing a lot of voluntary work, sponsrship are what makes Qt CS and the KDE conference happen. There will be sponsorship packages of all sizes. Info and update on this will be provided soon.

You’ll be invited to this conference by a Qt contributor where also registration details will be provided. Registration of session(s) and other practicalities regarding the Qt CS 2013, is found at the Qt Project Web wiki: Qt Contributors’ Summit 2013. Please don’t hesitate to contact us on the email-list: marketing (at) qt-project.org

Comments Off


Posted in Announcements, Contributors, KDE, Open Governance, Qt

Help needed

Published Wednesday September 5th, 2012 | by

So, we have the Qt 5 beta out! The next steps now are to polish it to make the Qt 5.0.0 release as impressive as possible.

One big, pending task we’ve identified is making sure the class reference documentation is consistent with the changes we’ve made in Qt 5. Since this was originally written when widgets were the only way to do GUIs in Qt, some of the documentation is rather widget-centric in how it presents things. There might also be other content in there that is no longer correct, or less relevant, with the changes made in Qt 5.

The only way to fix this is really to go through the classes manually. We need to actually read the documentation for each class to make sure it still makes sense and presents Qt in a way that give people the information they need to make good decisions. If it is somehow unclear or seems stuck in the past, we need to update it with something better.

One example of such an update was in the QSyntaxHighlighter docs, where the description of the class referred to a constructor which had been removed in Qt 5, when the class was made independent of widgets. This reference was simply removed. Another example was the QTextDocument docs, which have been rephrased a little to identify the class as a general rich text layout engine, and not only as the back-end for QTextEdit, which is just one isolated use case in the context of Qt 5. Note, though, that for the majority of classes, there will not be any issues, but we won’t know for sure until someone’s read the documentation and verified it.

If you’ve been looking to get into developing on the Qt Project, this might be good time to get started. It’s definitely a very useful way to get familiar with the different parts of Qt and the infrastructure around it, and the patches you’ll be making are simple and low risk.

To organize the work, we’ve made a wiki-page. If you want to help out, please edit the page and replace “unassigned” with your name next to the class you’re claiming to avoid duplicate work. If the class requires patching, please make sure the change is actually merged before you mark the class as “done”.

To get started with Qt development, go to the Qt Project homepage and look at the guides posted there. You might also have use for the QDoc reference documentation to figure out what all the magic tags are for.

Finally, just ask if you have any questions. We really appreciate any help we can get with this!

14 Comments


Posted in C++, Contributors, migrate, Qt

Qt 5, C++ and Qt Widgets

Published Wednesday April 18th, 2012 | by

We have seen the many questions and the concerns raised about our commitment to C++ and QWidget in Qt 5. I thought now would be a good time to address some of these concerns in this post.

The post on the Qt 5 alpha was focused on the new things we enable and add with Qt 5.

Let me just state it very clearly here:

QWidget and all derived classes are a core part of Qt 5 on the Desktop.

You can continue writing your application in exactly the same way as you have been doing with Qt 4.x.

We have promised to try to keep as much source compatibility with Qt 4.x as we can. And of course this includes QWidget and your application written in C++. This is not going away. Yes, the Qt Widgets module we have in Qt 5 is right now marked as ‘done’, which means we don’t have anybody actively working on new features for the module at this point in time. But this can change any day if someone has some interest or need to do more active development in this area.

What we did with Qt 5 is to add a new way to do applications with QML. I personally believe that over time we will see more and more apps being written that way, as I believe it is the better solution in the long term.

New user interfaces such as the Windows 8 Metro UI are not things we could simply add to our existing QWidget infrastructure. Adding support for the kind of animations used in these user interfaces is extremely difficult using QWidgets, as they were designed for the mostly static user interfaces that predominated until a couple of years ago.

The fluid animated user interfaces that are already there on Devices such as smartphones and tablets are now also starting to appear also on desktops. And they are simply not implementable using the QWidget infrastructure.

This implies that we needed to do something new here. And QML/Qt Quick was the answer we came up with to solve this problem. That’s why we’re investing in that area.

Our experience with QML over the last years has shown us that it is the superior technology for building UIs in the long term. If you want, you can simply use it as a more powerful replacement to .ui files. But you can also write some application logic in there using Javascript if you want.

It really is up to everybody what they make out of the options being given by Qt 5, and how they best like to use them.

C++ is and will stay our main programming language.

We have done significant work for Qt 5 adding many new C++ APIs. We have added support for C++11 in many places. And we’ll continue to do so, because larger scale applications written with Qt will be mostly written in C++ for a long time to come. And there’s nothing bad about this.

What we did with Qt 5 is to add another option into the mix. We want to make the usage of Javascript supported as well as C++ is supported. We are not making it the superior way or even the only way. That is a good thing, as it opens up new options for how you write your application.

If you want, you can do smaller pieces of application logic inside QML. It allows to do some rapid prototyping that can then be replaced by C++ in the final implementation. It gives you abilities to do application scripting. And for many apps it also gives you the option to write a big part of it in QML and Javascript.

Summary

With Qt 5, if you want to use Qt as you have always used it, please go ahead. It’s a fully supported way of doing things.

But I do believe that we will need more then what we have in Qt 4 for the longer term future. The expectations towards application UIs are changing drastically, especially when creating consumer-facing apps.

We need to have solutions available if we want Qt to stay relevant. That’s what Qt 5 is all about.

Cheers,
Lars

246 Comments


Posted in C++, Contributors, Qt

Cross compiling Qt for the masses

Published Friday April 13th, 2012 | by

Cross compiling Qt for particular devices/BSPs can be frustrating when operating from first principles and we are trying to improve the existing configure/qmake build infrastructure in Qt 5, as well as the associated documentation, in order to ease this burden. We are approaching the problem from 2 angles:

  • General cross compilation support
  • Direct target support

The general cross compilation support is being improved by:

  • Reworking the pkg-config logic
  • Introducing the -device flag to configure
  • Introducing the -sysroot flag to configure

The supported targets are documented here:

http://wiki.qt-project.org/Devices

and as you can see in the Raspberry Pi documentation, we have reduced compilation for this target down to:

./configure -prefix <your prefix> -release
  -device linux-rasp-pi-g++ -make libs
  -device-option CROSS_COMPILE=<your toolchain path>/bin/arm-none-linux-gnueabi-
  -sysroot <your sysroot path>

The resulting build has full (single process) OpenGL ES 2 support and keyboard support for the Raspberry Pi.

There is no need to patch any files as all the relevant changes have been upstreamed into Qt 5 where they can be adequately reviewed and QAed like any other Qt contribution. Needless to say this drastically increases the quality of the code finding its way on to these devices and should drastically improve the user experience when dealing with this kind of hardware for prototyping/productization/recreation. Sunlight is the best disinfectant, and we delight in consuming this dog food.

We heartily invite any (all!) chipset vendors/chipset customers/BSP vendors or interested parties to upstream relevant mkspecs and the associated code changes to Qt, in order to extend the breadth of Qt 5′s out-of-the-box device support. The move to Open Governance has made extending this support increasingly achievable, feasible and convenient and we are very excited about both Qt 5 as a whole and the current rate of development towards embedded (read constrained) Linux platforms.

13 Comments


Posted in Contributors, Embedded, Open Governance, Qt

Qt 4 moved to open governance

Published Tuesday January 10th, 2012 | by

Since we released Qt under open governance on qt-project.org, there was always one piece missing. The Qt 4 repository was so far still handled in the old system. This was done as a simple prioritization, to get the parts of Qt that we considered most relevant for the development community out first.

The main problem has been the additional work required to integrate Qt 4 with the continuous integration (CI) system used on qt-project. Thanks to the efforts of Sergio, Rohan and others this has now been (mostly) solved. We run the full CI setup (that includes both compilation and running the test suite) on both Linux and Mac OS X for Qt 4.8. On Windows we currently only run compile tests, running the automated tests on Windows is coming soon.

You can now find the Qt 4.x repository on codereview. Pushing and reviewing changes works the same way as for Qt 5.

Approvers and Maintainers are the same as for the respective areas in Qt 5, but it should be noted that I don’t expect a lot of further development to happen in Qt 4.8. The focus here should be on bug fixes, and patches should be reviewed with this in mind.

The Qt 4.6 and 4.7 branches are not CI tested, so extreme care should be taken when submitting to these branches, and I’d like to see a review from a Maintainer for any change going in there. Changes in these branches should be limited to security issues and severe bugs that can’t be worked around in user code.

Any pending merge requests in gitorious should be resubmitted through gerrit, as we’ll close merge requests on gitorious and turn the repository there into a readonly copy.

Enjoy!

9 Comments


Posted in Contributors, Qt

The Qt Project is live!

Published Friday October 21st, 2011 | by

I’m happy to announce that the Qt Project officially went live today. Starting today, development of Qt will be governed as a true open source project.

We now have qt-project.org – a website where all development of Qt will be centered, providing the same infrastructure and processes for everybody that wants to contribute to Qt.

Now that we are here, what next?

If you are interested in participating and becoming part of the Qt Project community, the first place to look is at the projects website at qt-project.org. This page gives a good overview on how to get started, and how you can become part of the community and contribute to Qt.

If you have already been working with Qt, you most likely have an account in Jira, our bugtracking tool. This account is required to get access to the central place where all development happens: codereview.qt-project.org.

Our Gerrit server at codereview.qt-project.org will function as the central place where patches get pushed to, and there the patches are then reviewed and tested. Everybody that has a Jira account can push patches to codereview as a Contributor.

Patches can be reviewed by anyone, and finally accepted or rejected by Approvers and Maintainers. You will also notice that we already have some non Nokians as Approvers and Maintainers. I’d like to especially mention that Thiago, the maintainer for QtCore (the one library everybody is using), is not working for Nokia. This is the most tangible evidence of what open governance means. I expect and hope to see even more non Nokians becoming Approvers and Maintainers in the future.

For details on how to contribute, please head over to www.qt-project.org.

For now we have only a few mailing lists available at lists.qt-project.org, but I expect this to change and to see more specialized lists as we move forward. The most important list is the general development mailing list development@qt-project.org. Note that the development mailing list is also a member of the announcement mailing list, so you will automatically get those as well.

We are continuing to use Jira for tracking bugs and requirements. The current installation at bugreports.qt.nokia.com will be moved over the next few weeks to the Qt Project as well.

True openness

The Qt project is a true open source project. We are inviting everybody to participate and help making Qt a better product.

All development will happen in one central location, with access for everyone at the same time. No more separate code flow for “Nokians vs others”, and no more time delays! What you see is what we see. Discussions, decisions and roadmapping will all happen in the community, by the community, for the community. Anyone can be a Contributor, and even an Approver or Maintainer if they show enough merit.

Talk with us about Open Governance at Qt Developer Days

Sessions regarding the Qt Project and open governance will be happening at Qt Developer Days, and I’ll also be talking about it during my keynote. If you are coming to the event, you will have an opportunity to learn more and get involved in the discussion. If you are considering coming to Dev Days, this discussion is one of many good reasons to get yourself there!

Conclusions and thanks

I am extremely happy to see that this move has now finally happened. I’d like to take the opportunity to thank all the people that have helped making this happen. There are many people that have contributed, but a few should be specifically mentioned : Thiago Macieira for driving the initial work on open governance, Marius Storm-Olsen for taking over much of that work, Cristy Hamley for handling all of the legal issues, and Olivia Puntanen for managing the project. Thank you all.

I am very much looking forward to starting a new chapter in the development of Qt, and excited to work with all of you towards making Qt an even better product.

87 Comments


Posted in Contributors, Qt

  1. Pages:
  2. 1
  3. 2
  4. 3
  5. 4