Get your tickets while they’re hot!

TL;DR; Get your tickets from here!

For the fourth year running, foss-north is taking place. Now bigger than ever.

It all started as a one day conference in a room with too much people in it. We gathered ten speakers and started something that continues to this day.

110 ten people in a room for 110 people.

Back then we, the three organizers: Jeremiah, Mikael and myself, joked over beers that we should have trainings, conference, community rooms and much more. A moderated FOSDEM was a crude description of what we wanted to build. But this was only us dreaming away.

During the past years we’ve tried different venues. We’ve gone from one day, one track to two days and two tracks. This year we decided to go for it all: four days, trainings, a community day and the conference.

Organizing a conference is to manage a chicken and egg type problem. You need speakers to get sponsors, and you need sponsors to get speakers to the venue. The same applies to the audience – visistors wants speakers, speakers wants visitors. This is why it takes time to establish a conference.

Last year we felt that we reached a tipping point – the call for papers was so full that we had to extend the conference with an additional day. We simply could not pick the right contents for a single day. This means that we feel that the conference part is established. If you want to speak, the call for papers is still open.

That takes us to the next steps. The community day consists of various projects and groups organizing workshops, hackathons, install fests, development sprints and whatnot throughout the city. We find venues (usually conference rooms) and projects and hope that people will come visit the various events. Again, starting from zero projects, zero venues and no real idea how many visitors to expect, we are trying to put this together. At the time of writing, it looks great. We have 7 projects and 5 venues fixed, but we are still looking for both projects and venues. If you want to join in, look at our call for projects.

The same logic applies to the training. Now we have training contents, all we need are visitors. The great thing is that our teachers, Michael Kerrisk and Chris Simmonds, are great to work with and understand our situation. Now we just have to work hard to make sure that we find students for them.

The final piece of the puzzle, which is not always visible to speakers and visitors, is the hunt for sponsors. Venues does not come for free, and we believe in compensating our speakers for their costs, thus we need sponsors. We offer the opportunity to host a booth during the conference days and the chance to meet our audience. We also believe that helping a conference focused on free and open source, is a way to contribute to the free and open source movement. For this we have a network of sponsors that we’ve worked with in the past (thank you all!) but as the conference grows, we need more help. If you want to join in, have a look at our call for sponsors

I’ve written a lot about speakers, sponsors and projects. Now all we need are visitors – lots and lots of visitors. So bring your friends to Gothenburg and join us at foss-north. The early bird tickets are available now. Get yours here!

Posted in foss-gbg, foss-north | Comments closed

Speak at foss-north 2019

Would you like to speak at foss-north 2019? This is an excellent opportunity to come join a great conference on the Swedish west coast and meet the free and open source community!

The call for paper is open until late February – but it always helps if you submit your talks early. The submissions are made here. We gather a mix of different speakers – experienced speakers and first timers, technically detailed and process oriented, new contents and really old stuff. As long as it is interesting and fun, you are more than welcome. You can check-out videos and slides for past events for inspiration.

There is also an opportunity for projects who wants to do something fun to join in. Be it a development sprint, an install fest, a workshop or just a general meetup – join in and be a part of the foss-north community day. Reach out to me (e8johan, gmail) and I’ll tell you more.

Posted in foss-north | Comments closed

TableView and Qt 5.12 / Qt Creator 4.8

I finally got around to doing the final merge for QmlBook this year.

I just merged the chapter on the brand new TableView. This let’s you show 2D data tables in an efficient way.

I also merged the version upgrade, so the text should now reflect what is available from Qt 5.12 and be based on menus and screens from Qt Creator 4.8.

During this update of the text, we took the decision not to upgrade all import statements to QtQuick 2.12. Instead, we use different versions in different places. However, the contents of Qt 5.12 is covered.

There are still two things left for the 5.12 branch. The first is to use the new input handlers, e.g. TapHandler instead of MouseArea. The second is to setup a release branch in the CI system so that there is a 5.12 version of the book built separately. I suspect that this will force me to learn more Travis tricks :-)

Posted in KDE, Qt | Comments closed

Merging QmlBook Contents

What better way to spend a lazy Christmas day than to merge some of the new chapters to the QmlBook?

Since having updated the CI system, there is a bit of manual merging forth and back to get each new piece of contents on-line. Specifically, rebase my fork’s master to upstream/master, then rebase my working branch on my master, and then pushing.

One of the newly added chapters cover Qt Quick Controls 2, which is the recommended way to create controls such as buttons, sliders, checkboxes, menues, and so on. Here we look at how you target various form factors such as desktop and mobile, but also how to maintain a common code base between the two.

The other new chapter has a look at Qt for Python from a QML perspective. This chapter goes from the very basic all the way to exposing a Qt model representing the data of an existing Python module to QML.

Posted in KDE, Qt | Comments closed

QmlBook gets CI/CD

Christmas is coming and a long and exciting fall is coming to and end. One of my projects during this fall has been to update the QmlBook. This was made possible by The Qt Company who generously stepped in and sponsored my work on this – thank you all!

I’ve worked away during the fall adding a whole bunch of new contents and the documentation people over at The Qt Company has joined in and helped with a language review. One frustrating aspect of the QmlBook project has unfortunately been that the CI/CD system has been broken for a very long time. This means that even the small typo fixes made over the past months has not made it beyond the source git repository.

All this changed tonight! After fighting with Travis, trying to understand why things around Sphinx Docs has broken, realizing that Travis has quirks – as has the old QmlBook deployment setup, I could finally merge pull request #221 – Implementing CI/CD (and then fiddled around with the last quirks). Big thanks to my co-author, Jürgen Bocklage-Ryannel, who reviewed and helped me through this.

To celebrate this, I took the liberty of changing the style of the page. This way, you will recognize that you are browsing the new, updated QmlBook.

There were unfortunately a few sacrifices made during this transition. We lost support for generating QtHelp (it can most likely be fixed) and we dropped support for translations during a transitional period. There is a plan for both translations and different parallel versions of the book. The idea is to tune each version of the book to a specific Qt version.

To sum things up: expect broken links. Expect missing contents. But know that the contents is up-to-date!

Now – go enjoy Christmas! God Jul på er alla!

Posted in KDE, Qt | Comments closed

Video Editing for foss-gbg

Editing videos for foss-gbg and foss-north has turned into something that I do on almost a montly basis. I’ve tried a few workflows, but landed in using kdenlive and, when needed, Audacity. I’m not a very advanced audio person, so if kdenlive would incorporate basic noise reduction and a compressor, I stay within one tool.

Before I describe the actual process, I want to mention something about the hardware involved. There are so many things that you can do when producing this type of contents. However, all the pieces that you add to the puzzle is another point of failure. The motto is KISS – Keep It Simple Stupid. Hence, we use a single video camera with an integrated microphone. This is either an action cam, or a JVC video camera. In most cases this just works. In some cases the person talking has a microphone and then we try to place the camera close to a speaker. It has happened that we’ve recorded someone whispering just by the camera…

As we don’t have a dedicated microphone for the speaker, we get an audio stream that includes the reaction of the audience. That is in my opinion a good thing. It captures the mood of the event. However, we also get quite a lot of background noise which is bad. For this, I rely on this workflow from Rich Bowen. Basically, I extract the audio stream from the recording, massage it in Audacity, and then re-introduce it.

I’ve found it easier to cut the video prior to fixing the audio. This usually means find the start and the end of the talk, but in some cases it is more complex. E.g. removing parts of the Q&A due to reasons, or cutting out a demo that makes no sense when watching the video.

Once in Audacity, I generally pick out a “silent” part of the recoding to learn a noise profile. I then apply a noise reduction effect to the entire recording. This commonly produces a somewhat distorted sound (like if spoken into a can), but the voice of the speaker comes across nicely. After that, I usually apply a compressor effect to balance the loud and quite parts better. I’ve noticed that speakers often start out with a loud voice, and then softens the voice during the talk. For such cases, the compressor helps. It also helps balancing the sound level during Q&A where the audience might be quite or loud compared to the speaker depending on the layout of the venue.

Once the video and audio are cut and filtered, we need some intro and exit screens. I create these using LibreOffice Impress. I have created a template for the title page with the title of the talk and the name of the speaker, followed by a slide with room for the sponsor logo. This has a white background as logos mix badly with the crazy yellow colour of foss-gbg. Finally there is an exit slide which just says foss-gbg.se. I then export the slides to pdf and use ImageMagick to create pngs from them. Since I’m lazy, I just produce huge pngs that I mogrify to the right size. The entire flow looks like this:

libreoffice --headless --convert-to pdf slides.odp 
convert -density 300 -depth 8 -quality 85 slides.pdf slides.png
mogrify -resize 1920x1080 slides*.png

The very last step of the process is to overlap the intro and exit screens with the start and end of the video in a good way. I mix this with fading the audio in and out. The trickiest is fading in, as it is nice to hear the first words of the speaker but you don’t want the noise from the audience. I’ve found that no matter what, you need to fade in the sound, even if the fade only lasts for a fraction of a second. Fading out is easy as things usually ends in an applause.

Then it is all about clicking render, remembering to change the name of the output file and uploading to the foss-gbg YouTube channel.

Posted in foss-gbg, foss-north, KDE | Comments closed

Working on QML Book

Do you remember QML Book? It started as a project between me and Jürgen Bocklage-Ryannel where we tried to fix the problem that there is no QML book out there.

Back in the Qt 5.2 days, we spent wrote about a year. Unfortunately, the project has mainly been sitting idle since then. I’ve poked at issues every now and then, and Jürgen has done various fixes as well.

Thanks to The Qt Company, this is changing. This autumn, it sponsors me to work on the project. The current plan is to add a chapter to Qt Quick Controls 2, and to update the entire contents to Qt 5.12 and Qt Creator 4.8. By doing so, many of the remaining bug reports will be resolved.

Other things in the backlog are getting the CI system back into shape and having a native speaker edit the language. All in all, this will result in an up-to-date book on QML. If you want to help out, just reach out to me or send me your pull requests. All help is welcome!

Posted in KDE, KDE 4, Qt | Comments closed

QML Weather

I recently took some time to develop a photo frame style home automation control panel. The idea is to control some common tasks of my home assistant setup from a panel instead of having to rely on the phone. To hide the panel, it currently act as a photo frame until touched.

The build is based on a Raspberry Pi 2 with the official touch screen attached and a USB wifi dongle. Nothing fancy, but still good enough.

One of the features that I wanted was a weather forecast, so I decided to use Yr’s xml weather as a base for this. The result is the YrWeatherModel QML item.

The weather forecast overlay.

The presentation side of things is the fairly straight forward piece of QML shown below, resulting in the overlay shown above.

Row {
    anchors.bottom: dateText.bottom
    anchors.right: parent.right
    anchors.rightMargin: 40

    spacing: 20
    Repeater {
        delegate: Column {
            spacing: 2
            Text {
                anchors.horizontalCenter: parent.horizontalCenter
                color: "white"
                font.pixelSize: 16
                font.bold: true
                text: {
                    switch (period) {
                    case 0:
                        "00 - 06"
                        break;
                    case 1:
                        "06 - 12"
                        break;
                    case 2:
                        "12 - 18"
                        break;
                    case 3:
                    default:
                        "18 - 00"
                        break;
                    }
                }
            }
            Image {
                anchors.horizontalCenter: parent.horizontalCenter
                source: symbolSource
            }
            Text {
                anchors.horizontalCenter: parent.horizontalCenter
                color: "white"
                font.pixelSize: 16
                font.bold: true
                text: precipitation + "mm"
            }
            Text {
                anchors.horizontalCenter: parent.horizontalCenter
                color: "white"
                font.pixelSize: 16
                font.bold: true
                text: temperature + "°C"
            }
        }

        model: weatherModel.model
    }
}

This is followed by the model itself, and a small notice of the data source.

YrWeatherModel {
    id: weatherModel
    place: "Sweden/V%C3%A4stra_G%C3%B6taland/Alings%C3%A5s"
}

Text {
    anchors.bottom: parent.bottom
    anchors.right: parent.right
    anchors.bottomMargin: 5
    anchors.rightMargin: 40
    text: weatherModel.dataSourceNotice
    color: "white"
    font.pixelSize: 16
    font.italic: true
}

Diving into the model itself, we hit the interesting parts. The structure looks like this:

Item {
    id: root

    property alias model: weatherModel
    property int refreshHour: 1     // How often is the model refreshed (in hours)
    property int dataPoints: 6      // How many data points (max) are expected (in 6h periods)
    property string place           // Place, URL encoded and according to Yr web site, e.g. Sweden/V%C3%A4stra_G%C3%B6taland/Alings%C3%A5s
    readonly property string dataSourceNotice: "Data from MET Norway"

    ListModel {
        id: weatherModel
    }

    Timer {
        interval: 3600000 * root.refreshHour
        running: true
        repeat: true
        onTriggered: {
            _innerModel.reload();
        }
    }

    XmlListModel {
        id: _innerModel

        query: "/weatherdata/forecast/tabular/time"

        source: (place.length === 0)?"":("https://www.yr.no/place/" + root.place + "/forecast.xml")

        XmlRole { name: "period"; query: "string(@period)" }
        XmlRole { name: "symbol"; query: "symbol/string(@number)"; }
        XmlRole { name: "temperature"; query: "temperature/string(@value)"; }
        XmlRole { name: "precipitation"; query: "precipitation/string(@value)"; }

        onStatusChanged: {
            // ...
        }
    }
}

As you can see, the model consists of an inner model of the type XmlListModel. This model is refreshed by a timer (don’t refresh too often – you will most likely be auto-banned by Yr). At the top, there is also a ListModel that is the actual model used by the user interface.

The reason for the ListModel to exist is that I wanted to be able to limit how many data points I show. Each data point represents a six hour window, and I’d like 6 of them, i.e. one and a half day of forecasting.

The onStatusChanged handler in the XmlListModel takes care of this in the following for loop:

onStatusChanged: {
    if (status === XmlListModel.Ready)
    {
        for(var i = 0; i< root.dataPoints && i < count; ++i)
        {
            var symbol = get(i).symbol;
            var period = parseInt(get(i).period);
            var is_night = 0;

            if (period === 3 || period === 0)
                is_night = 1;

            weatherModel.set(i, {
               "period":period,
               "symbol":symbol,
               "symbolSource":"https://api.met.no/weatherapi/weathericon/1.1/?symbol=" + symbol + "&is_night=" + is_night + "&content_type=image/png",
                "temperature":get(i).temperature,
                "precipitation":get(i).precipitation
                });
        }
    }
    else if (status === XmlListModel.Error)
    {
        console.warn("Weather error")
        console.warn(errorString());
    }
}

As you can tell, this code has *very* limited error handling. It is almost as it has been designed to break, but it works. The code also shows how convenient it is to connect to online services via QML to build simple, reusable, models that can be turned into beautiful user interfaces.

Next time I have some free time, I’ll look at interfacing with the public transport APIs. Then I will have to deal with JSON data and make explicit XmlHttpRequest calls.

Posted in Embedded, KDE, KDE 4, Linux, Qt, RaspberryPi | Comments closed

Complicating Licensing

I’ve recently seen a couple of attempts to present non-open source licensing as almost open source. What I’m talking about is Commons Clause and fair source. This sounds a lot like the failed shared source model promoted by companies such as Microsoft in the early 2000. Yes, I’m looking at you redis and neo4j.

What I find particularly disturbing is the way that both, but especially Commons Clause, attempts to piggyback on the good name of open source. The naming is very close to Creative Commons, and the way that the clause is intended to be introduced is very confusing for the user as the user would see a familiar open source license, and then just a “small” exception.

I would argue that the way to go about this is to combine a strong copyleft license such as GPLv3, LGPLv3 or AGPLv3, with a CLA. That way a dual licensing model could be used to create a business model. If that is not possible, the [A/L]GPLv3 needs to be improved – not complicated by additional clauses added by a third party.

The consequence that anyone accepting the strong copyleft can do whatever they like with the software is not a bug in the copyleft license, but instead a feature. Actually, this is one of the core four freedoms of free software.

At the end of the day, my cynical self gets the impression that this is something that you add to an existing project once it has gained traction and then hope that it does not render in fork. If something like the Commons Clause would have been present from the start, the projects would never had gained the user bases and communities that they are enjoying today.

Posted in Licensing | Comments closed

Work v2.0

Returning to work this autumn has a slightly different feel to it as I’m working on getting a new business up and running. This is both rewarding and stressful at once. Strangely enough, it actually felt good to get up early to get to work.

The major hurdle during the bootstrapping phase is how to handle free time. I do have more free time at the moment, as I’m only working part-time for my current customer. However, I also have an infinite backlog of things to do. This is everything from basic administration, doing sales to pet projects.

I guess what it comes down to is to handle and prioritize infinity. For now, I have gbgcpp, foss-gbg and Kuro Studio to fill my time. It will be fun!

Posted in Miscellaneous | Comments closed
  • September 2019
    M T W T F S S
    « Aug    
     1
    2345678
    9101112131415
    16171819202122
    23242526272829
    30