Now I finally have my very own domain name! The old Blogger site is still available if anyone wants to see it but for all future intents and purposes, this will be the place where new blog posts will be put up. While I could configure all traffic to the Blogger site to redirect to this one, the old site has grown on me so much over the years that I feel that it would be a shame to hide it that way.
I had to migrate from Blogger because it is more than evident that Blogger has been getting less love from Google than it deserves. Take for instance, the Blogger web-based post editor - a shining example of an undeveloped relic of Google's products. Posts never autosaved or had any manual version control and a few misplaced keypresses could cause you to lose all your writing progress. Inserting images is a chore and putting up more complicated parts of text such as code blocks and sub-headings is even worse.
Of course as with most things in software development, there are workarounds for everything. The work-around which I had used for the last few blog posts was to write directly in Markdown and then convert it to HTML with pandoc to copy paste in the Blogger editor. Even so, this is clearly sub-optimal and I was spending more time wrestling with the Blogger editor to make my pages look good than I was spending writing actual content. The Blogger theme which I was using appealled to me as 13 year old (heck, it still appeals to me), but it was growing long in the tooth and only had basic support for responsive design and mobile devices. With all these things in mind, I started looking for a new home for my blog somewhere in the middle of last December on a break from college.
I first looked at WordPress. At first, it seemed like my search for a new blogging platform would stop here. Open-sourced, a great browser editor, a cohesive Android app, direct editing in Markdown, local installation for testing, and support for plugins made WordPress everything Blogger wasn't. I loved the number of themes and customisation WordPress provided. But the love was short lived, and it ended when I started researching hosting options for WordPress. Most solutions required me to rent a web-server on a monthly basis and I had no idea what tier of server to get as my blog had only recently seen a huge surge in pageviews. Not to mention, the cost of maintaining a website with such a setup was by no means cheap. This is when I started asking to my geeky friends about how they maintained their own personal websites.
The talks were very helpful, it made me realise that a dynamic blogging solution such as WordPress was overkill for a humble blog of less than 30 published posts like this one. Having a static site made so much more sense. I could write directly in Markdown, in the text editor of my choice. Not to mention, it made the workflow of writing a blog post just like I wrote code, make, git commit, and git push straight to GitHub Pages. GitHub Pages, by the way, offers completely free hosting for static sites. This means that the only thing I would need to pay for would be the custom domain name, a nominal ₹700 ($10) a year, an amount half of what I would be paying for a month of paid hosting. Plus, it would let me get my hands dirty with a bit of web development, something which I had pushed back for a long time.
I decided to start this - what I knew was going to be painful task at about 11pm on a night I just knew I wouldn't be able to sleep.
The first step was to convert all my Blogger posts to Markdown. There were some tools online but all of them messed up the conversion pretty badly. After some more digging, I ended up using Aaron Swartz's html2text Python library which did a better job than other solutions in generating some useful Markdown. I still needed to edit every generated Markdown file by hand to make it something I would be happy with using on my site. I then had to export all the images I had on my Blogger site. This lead to a few more laborious hours of saving each image on the site by hand (Right Click -> View as Image -> Save As). It did cross my mind to automate everything with a script, but it was going to take more time to automate everything and check if the automation was working than it was to do the grunt work of pulling the images. With all the resources safely on my laptop and backed on my Dropbox, I took the next step of looking at static site generators to convert my lovingly handmade Markdown files to HTML.
GitHub Pages seemed to heavily advocate Jekyll so I went with it first. With some tinkering to get the Ruby dependencies installed and posts adapted for Jekyll with the Front Matter content, I managed to get a pretty presentable blog running on localhost:4000/ at 5am on that day. With a quick push to my github.io site, I decided to call it a night and slept off a sleep-deprived session of hacking.
The next few days I played with some more Jekyll themes and found that there were many things I didn't like about it. For one thing, it was written in Ruby which I have no experience with. Themes didn't look easy to work with and there was no native support for tags (there is a workaround for this, but due to my lack of Ruby-fu, it all looked terribly arcane to me). I then put the blog migration on the back burner for a while to work on projects at my college's Automation & Robotics Club.
A few weeks later I decided to look at the blog with the fresh perspective which comes with taking a break. Again, I poked around to look for alternatives to Jekyll. There was one such alternative which ticked all my boxes - a static site generator called Pelican. As WordPress looked inherently superior to Blogger, Pelican looked inherently superior to Jekyll for what I wanted to do with it. For example, it had built-in support for tags, had a theming engine, supported Markdown and reStructuredText, and had several easy to install plugins. Above all, Pelican is written in Python which made it so much easier for me to mess around with it. There were some more modifications to make to the Markdown files (particularly with the post metadata), but it was so trivial that it didn't pain one bit to modify all the files. Not too long after I settled on Pelican, I found a theme which made my blog look exactly how I wanted it to look. The Pure Single theme also has nifty support for custom sidebar images, which I used on some select blog posts.
There was some initial trouble with setting a blog subfolder in the site and getting images to work on some auto-generated sites (such as the Tags and Categories pages). It later turned out that it was some problem with localhost/ not finding the paths correctly to the images and the site was totally fine when published to the GitHub Pages site. After only three days of using Pelican, I had something which I was willing to show off. The next step was much more straightforward for a change - registering a domain name. I looked into a few options such as GoDaddy and Hover, but Namecheap had a lot more positive reviews than GoDaddy and was the cheapest of the lot. The site configuration to serve pages from GitHub's servers was not more than a 10 minute procedure, and I finally had the site you are reading this article on right now.
There will be a lot more changes coming up on this blog, some of them aesthetic and some functional. I'm also probably going to change the name of this blog sometime soon, to something which is more reflective of my current tastes and sensibilities.
The first ever WikiToLearn India conference was a 2 day single track event held on the 18th and 19th of January, 2017 in Jaipur, India. The event welcomed talks from all domains of technology, but admittedly, talks around KDE and MediaWiki were preferred. Having worked extensively on porting JoyStream's codebase from QMake to CMake and also … Continue reading A look back at the WikiToLearn India conference, 2017
Five years ago (I’m completely shocked how the time flies), we were working on Plasma Active, and one of the ideas was to allow the user to create private activities in which all the data would be encrypted.
Now, while the idea itself was solid, there were big problems with its realization. There was no way to force applications to separate the configuration and other data based on whether the user is in the encrypted activity or not. Especially since the same application can run in multiple activities.
For those reasons, the idea was abandoned. I didn’t like the fact that I spent a lot of time on it just for it to be thrown away, so encryption always stayed in my mind.Enter Plasma Vaults
If the idea to have activities encrypted can not work because of the things not controllable by us, then we need to do something more obvious and transparent, so that the user can know exactly which data is secure, and which not.
Instead of having something as abstract as an activity encrypted, Plasma Vaults will allow you to create encrypted directories.
Sometimes we want to keep specific documents private. Sometimes we are actually forced to do so (I’ve seen enough work contracts that force you to keep the job-related data as secure as you know how to). And sometimes we have to share our computer with others while keeping our data completely private.
Plasma Vaults allow you to easily create and manage EncFS encrypted directories (other encryption systems might be supported in the future).
The vault creation dialogue will need more work. While most of the text in it is important, we’ll need to think of something to make it less daunting to look at.Activities
One of the things that did not survive from the original concept is that the encrypted drive is tightly bound to an activity.
But still, that does not mean there can not be a connection between them. The vaults are usually related to the projects that we work on, and one of the main use-cases of activities is the project handling.
So, for each vault, you can choose which activities it should be available on. It will not be automatically unlocked when you enter said activities, but it will be automatically closed when you exit them.
This might be a bit annoying if you often switch between activities, but I’d always put security above convenience.UI
Currently, the UI is not as polished as it should be. Some of the problems are in the Plasma Vault code itself, but some are in the KF5 widgets.
This is not the only way to keep your data private. Lately, most Linux installers allow you to create an encrypted home partition, or to encrypt the whole system including the swap.
But these cover a different use-case. They cover the case when your device gets lost while turned off.
They do not cover the possibility that someone might access your system while it is running. Plasma Vaults fill this void by making the attack surface smaller – instead of having all data unlocked at once, you can do it piece by piece – it is more granular.
This does not mean that using only Plasma Vaults will make your data more secure than encrypting the whole system, it just covers a different set of possible attacks. It is probably worth it to combine both if you are doing really secret work.
I am boarding my flight to Brussels to attend FOSDEM.
The Desktops DevRoom will be a blast again this year. While I have been in charge of it for 6? years already, the last two (since my twins) were born I had organized remotely and local duties were carried on by the Desktops DevRoom team (thank you Christophe Fergeau, Philippe Caseiro and others!).
I am anxious at meeting old friends again. I will be at the beer event today.
Video streaming will be available and thanks to the Video Team. If you want to help, please contact us in the email@example.com mailing list, or directly at the devroom.
Also, this year will be the first for me using the job corner to recruit: my company (everis) is recruiting globally for many open positions. Drop us a mail at firstname.lastname@example.org with your CV, desired position and location (we have direct presence in 13 countries and indirect in 40 countries) and I will make sure it reaches the right inbox.
I haven’t talked about it much, but the last few months we’ve been busy working on Kube and we’re slowly closing in on a first tech preview.
I’ll be at FOSDEM over this weekend, and I’ll give a talk on Sunday, 16:20 in room K.4.401, so if you want to hear more be there!
…or just find me somewhere around the Kolab or KDE booth.
See you at FOSDEM!
To enable global menus open System Settings, go into the Application Style category, and in the Widget Style settings you will find a tab called Fine Tuning. On this tab you can find the new Menubar options. You can change to either a Title Bar Button, which will tuck the menu into a tiny button into the window decoration bar at the top, or the Application Menu widget, allowing the associated Plasma panel to supply the menu in a fixed location.
To apply the change, your applications need to be restarted, so ideally you’ll simply log out and back in again.
To add an Application Menu to Plasma, simply right click on the desktop and add the Panel called Application Menu Bar.
Enjoy your new Plasma 5.9 with global menu bars!
Krita 3.1.2, released on February 1st 2017, is the first bugfix release in the 3.1 release series. But there are a few extra new features thrown in for good measure!Audio Support for Animations
Import audio files to help with syncing voices and music. In the demo on the left, Timothée Giet shows how scrubbing and playback work when working with audio.
- Available audio formats are WAV, MP3, OGG, and FLAC
- A checkbox was added in the Render animation dialog to include the audio while exporting
- See the documentation for more information on how to set it up and use the audio import feature.
Audio is not yet available in the Linux appimages. It is an experimental feature, with no guarantee that it works correctly yet — we need your feedback!
- Ctrl key continue mode for Outline Selection tool: if you press ctrl while drawing an outline selection, the selection isn’t completed when you lift the stylus from the tablet. You can continue drawing the selection from an arbitrary point.
- Allow deselection by clicking with a selection tool: you can now deselect with a single click with any selection tool.
- Added a checkbox for enabling HiDPI to the settings dialog.
- remove the export to PDF functionality. It is having too many issues right now. (BUG:372439)
- The transform tool can now scale around a pivot point. You can activate this using a special button in the Tool Options and dragging the corners or by pressing Alt while dragging the corner
There are also a lot of bug fixes. Check the full release notes!Get the Book!
If you want to see what others can do with Krita, get Made with Krita 2016, the first Krita artbook, now available for pre-order!Give us your feedback!
Almost 1000 people have already filled in the 2017 Krita Survey! Tell us how you use Krita, on what hardware and what you like and don’t like!Windows
Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.
- 32 bits Windows: krita-126.96.36.199-x86-setup.exe
- Portable 32 bits Windows: krita-188.8.131.52-x86.zip
- Debug symbols. (Unpack in the Krita installation folder)
- 64 bits Windows: krita-184.108.40.206-x64-setup.exe
- Portable 64 bits Windows: krita-220.127.116.11-x64.zip
- Debug symbols. (Unpack in the Krita installation folder)
- 64 bits Linux: krita-3.1.2-x86_64.appimage
A snap image for the Ubuntu App Store will be available soon. You can also use the Krita Lime PPA to install Krita 3.1.2 on Ubuntu and derivatives.OSX
- OSX disk image: krita-18.104.22.168.dmg
- Source code: krita-22.214.171.124.tar.gz
For all downloads:
For years and years already Ubuntu’s installer, Ubiquity, has an OEM mode. And for years and years I know it doesn’t really work with the Qt interface.
An understandable consequence of not actually having any real-life use cases of course, disappointing all the same. As part of the KDE Slimbook project I took a second and then a third look at the problems it was having and while it still is not perfect it is substantially better than before.
The thing to understand about the OEM mode is that technically it splits the installation in two. The OEM does a special installation which leads to a fully functional system that the OEM can modify and then put into “shipping” mode once satisfied with the configuration. After this, the system will go into a special Ubiquity that only offers the configuration part of the installation process (i.e. User creation, keyboard setup etc.). Once the customer completed this process the system is all ready to go, with any additional software the OEM might have installed during preparation.
Therein lies the problem in a way. The OEM configuration is design-wise kind of fiddly considering how the Qt interface is set up and interacts with other pieces of software (most notably KWin). This is double true for KDE neon where we use a slightly modified Ubiquity, with the fullscreen mode removed. However, as you might have guessed, not using fullscreen leads to all sorts of weird behavior in the OEM setup where practically speaking the user is meant to be locked out of the system but technically he is in a minimal session with a window manager. So, in theory, one can close the window, when started the window would be placed as though more windows are meant to appear, and it would have a minimize button etc. etc. All fairly terrible. However also not too tricky to fix once one has the identified all problems. Arguably that is the biggest feat with any installer change. Finding all possible scenarios where things can go wrong takes days.
So, to improve this the KDE Visual Design Group‘s Jens Reuterberg and I again descended into the hellish pit that is Qt 4 QWidget CSS theming on a code base that has seen way too many cooks over the years. The result I like much better than what we started out with, even if it isn’t perfect.
The sidebar has had visual complexity removed to bring it closer to a Breeze look and feel. Window decoration elements not wanted during OEM set up are being removed by setting up suitable KWin rules when preparing for first boot.
Additionally, we will hopefully soon have enough translations to push out a new slideshow featuring slightly more varied visuals than the current “Riding the Waves” picture we have for a slideshow.
For additional information on how to use the current OEM mode check out the documentation on the KDE UserBase.
I was sorely remiss not to blog more during the Plasma 5.9 dev cycle. While 5.9 packs a fair amount of nice new features (e.g. here's the widget gallery in Application Dashboard at some point during development), there was not a peep of them on this blog. Let me do better and start early this time! (With 5.9 out today ...)
Folder View: Spring-loading
Spring-loading functionality in Plasma 5.10's Folder View (click for YouTube)
Folder View in Plasma 5.10 will allow you to navigate folders by hovering above them during drag and drop. This is supported in all three modes (desktop layout, desktop widget, panel widget), and pretty damn convenient. It's a well-known feature from Dolphin, of course, and now also supported in Plasma's other major file browsing interface.
Folder View packs a lot of functionality - at some point I should write a tips & tricks blog on some of the lesser known features and how they can improve your workflow.
Performance work in Folder View ... and elsewhere!
But that's not all! I've also been busy performance-auditing the Folder View codebase lately, and was able to extract many savings. Expect massively faster performance scrolling big folders in big Folder View widgets, lower latencies when navigating folders, and greatly improved Plasma startup time when using Folder View widgets on the desktop. In the case of big folder + big widget, a 5.10 Folder View will also use quite a bit less memory.
I've done similar analysis of other applets, e.g. the Task Manager and the Pager, and done both smaller improvements or looked into more fundamental Qt-level issues that need addressing to speed up our UIs further.
Others on the Plasma team have been up to similar work, with many performance improvements - from small to quite large - on their way into our libraries. They improve startup time as well as various latencies when putting bits of UI on the screen.
While it's still very early in the 5.10 cycle, and it won't be shy on features by the end, performance optimization is already emerging as a major theme for that upcoming release. That's likely a sign of Plasma 5's continuing maturation - we're now starting to get around to thoroughly tuning the things we've built and rely on.
We are delighted to announce the release of Qbs 1.7 “Technical Ecstasy”!
While Qbs 1.7.0 was actually released back in mid-December, we decided to postpone the announcement until after last week’s 1.7.1 patch release in order to get in a few more bug fixes.What’s new?
In addition to lots of bugfixes and smaller improvements, as well as some significant performance enhancements, this release also brings a number of new features. Let’s start with the largest and most interesting:Generators
Generators are a major new feature in Qbs 1.7 that enables deep integration with your favorite third-party development tools.
The Generators API is designed to be very generic. It provides a means for developers to create “plugins” that perform arbitrary processing on the build graph. So, far we’ve used this to create several generators which output Xcode* and Visual Studio project files. This allows you to develop your projects in your favorite IDE, while still retaining the full power and expressibility of the Qbs build engine.
We’ve also received a community contribution that outputs a Clang compilation database file. This allows Clang-based tools to scan the sources exactly like the compiler, independently of the build system. We’re excited to see what other generators the community might come up with.
To get started with generators, try the qbs generate command on your project. The generators documentation will be available in the manual in a future release.
Note that the generators features are still very experimental. We will greatly appreciate your feedback in this area.
* the Xcode generator is scheduled for release in Qbs 1.8Other new features
- Group items can now be nested. This allows Groups to be structured more naturally, as a Group’s condition property is logically ANDed with its parent’s. It also makes Groups more useful when placed into dedicated files as the inherited QML-like syntax requires a root element.
- qrc files can be automatically generated from your project file, obviating the need to manually maintain multiple identical file lists. This functionality is part of the Qt.core module and introduces a couple of new properties which allow you to control how files in your project should be automatically added to a generated qrc file.
- There is now much more complete documentation on Rule authoring. This has been one of our biggest requests in the documentation area.
- Stricter type checking for properties in Qbs project files, which should help make certain syntax errors much clearer.
- Microsoft Visual Studio 2017 support in the C/C++ module.
- QtScxml support in the Qt modules.
- Support for building Inno Setup installers.
One last thing worth mentioning is that the Open Source C++ package manager Conan has added support for Qbs. We believe integrations like this which make it easier to integrate third-party content with your projects are a great ecosystem boon.Try It!
The Open Source version is available on the download page, and you can find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC on #qt-qbs on chat.freenode.net, and on the mailing list. The documentation and wiki are also great places to get started.
Qbs is also available on most major packaging systems (Chocolatey, MacPorts, Homebrew) and updated on each release by the Qbs development team. It can also be installed through the native package management system on a number of Linux distributions including but not limited to Debian, Ubuntu, and Arch Linux.
Qbs 1.7.1 is also included in Qt Creator 4.2.1, which was released last week.
Following the recent addition of easy DBus service snapping in the snap binary bundle format, I am happy to say that we now have some of our KDE Applications in the Ubuntu 16.04 Snap Store.
To use them you need to first manually install the kde-frameworks-5 snap. Once you have it installed you can install the applications. Currently we have available:
- ktuberling – The most awesome game ever!
- kbruch – Learn how to do fractions (I almost failed at first exercise :O)
- katomic – Fun and education in one
- kblocks – Tetris-like game
- kmplot – Plotting mathematical functions
- kgeography – An education application for learning states/countries/capitals
- kollision – Casual ball game
- kruler – A screen ruler to measure pixel distance on your screen
The Ubuntu 16.04 software center comes with Snap store support built in, so you can simply search for the application and should find a snap version for installation. As we are still working on stabilizing Snap support in Plasma’s Discover, for now, you have to resort to a terminal to test the snaps on KDE neon.
To get started using the command line interface of snap you can do the following:sudo snap install kde-frameworks-5 sudo snap install kblocks
All currently available snaps are auto generated. For some technical background check out my earlier blog post on snapping KDE applications. In the near future I hope to get manually maintained snaps also built automatically. Also from-git delivery to the edge channel is very much a desired feature still. Stay tuned.
A couple of years ago during a hackathon, a couple of us wrote a Qt wrapper around PDFium, the open-source PDF rendering engine which is used for viewing PDFs in Chromium. There have been a few fixes and improvements since then. Now we (finally) have made this module available under the LGPLv3 license.
QPdfDocument can render a PDF page to a QImage, and there is QPdfBookmarkModel which can be used for a bookmarks view. There is an example application: a widget-based PDF viewer.
If you want to try it out, here’s how to get started:git clone git://code.qt.io/qt-labs/qtpdf cd qtpdf git submodule update --init --recursive qmake make cd examples/pdf/pdfviewer qmake make ./pdfviewer /path/to/my/file.pdf
There is some work in progress to add support for PDF in QtQuick, to treat it as an ordinary image format and to add support for multi-page image formats in general, but we don’t have any particular target release date yet.
Simple Menu v1.0
Quite a while ago already I wrote a launcher menu widget named Simple Menu. It's using the same backend I wrote for our bundled launchers, and it's a little bit like Application Dashboard scaled down into a small floating window, plus nifty horizontal pagination. It's also really simple and fast.
While some distributions packaged it (e.g. Netrunner Linux), it's never been released properly and released - until now! Starting today, you can find Simple Menu on the KDE Store and install it via Add Widgets... -> Get new widgets in your Plasma.
Please note that Simple Menu requires Plasma v5.9 (to be released tomorrow). Actual v5.9, not the v5.9 Beta - it relies on fixes made after the Beta release.
Note that throughout this blog post, the term “Apple Platforms” will be used to refer to all four Apple operating systems (macOS, iOS, tvOS, and watchOS) as a whole.
I thought it would be a good time to share some of the highlights of what’s new in Qt on Apple Platforms with the recent release of Qt 5.8.New Platforms
To start off, Qt now has Technology Preview level support for Apple TV and Apple Watch devices beginning in Qt 5.8. This completes our offering to support all four Apple Platforms – macOS, iOS, tvOS, and watchOS.tvOS (Apple TV)
Qt for tvOS is 95% similar to iOS (even the UI framework is also UIKit) and as a result, contains roughly the same feature set and supported modules as iOS, with the notable exception of QtWebEngine.
The major difference between the two platforms is input handling. iOS has a touch-based model that maps fairly well to a traditional point and click desktop interface from a programming perspective, while tvOS has a focus based model. This means that you don’t have a canvas which can receive input at a particular point (x,y coordinate), but rather an abstract canvas in which you “move” the focus to a particular object. When an object has focus, you can use the Apple TV Remote to trigger an action by clicking its trackpad or pressing the Menu or Play/Pause buttons.
Qt supports some aspects of the tvOS input model (scrolling and clicking are recognized), but there will be some degree of manual work handling input events in QML to build a tvOS app. Most basic navigation actions on the Apple TV Remote are exposed as keyboard events in Qt, and gesture recognizers can be used for more complex multitouch input. We are still exploring ways to provide mechanisms that make it easier to work with this new input model.
We’d also like to thank Mike Krus doing the initial work of porting Qt to tvOS, and who is now the platform’s maintainer.watchOS (Apple Watch)
Qt for watchOS is also heavily based on iOS. However, it is not possible to run QML or any other Qt based UI on the watch using public APIs because the primary interface API is WatchKit (as opposed to UIKit). Therefore, Qt can currently only be used for non-UI tasks such as networking, audio, backend graphics processing, etc. If the available watchOS APIs change in the future then we can certainly explore the possibilities at that point.
I am also the watchOS platform maintainer, so please feel free to send me any questions or feedback.Shared Libraries on iOS
Only static libraries were permitted for most of iOS’s existence, as many iOS developers are no doubt aware. Apple’s App Store requirements prohibited shared libraries even though the underlying operating system supported them since 1.0. Finally, with the release of iOS 8 and Xcode 6 in 2014, shared libraries/frameworks became officially supported by Apple for use in applications submitted to the App Store. Unfortunately, while this feature did not make it in time for the Qt 5.8 release… Qt 5.9 will support them too (also for tvOS and watchOS)!
To build Qt as shared libraries on iOS, all you need to do is pass the -shared option to configure (and this will be the default in the next release). Note that shared libraries require a deployment target of at least iOS 8.0, which will also be the minimum requirement for Qt 5.9.
With shared libraries, you can simplify your development workflow by not having to maintain separate code paths for static libraries on iOS and shared libraries on other platforms. Shared libraries also allow you to:
- When using App Extensions (as both your main application and your extension executables may link to the same copy of the Qt frameworks), reduce memory consumption and reduce disk space consumption on your users’ devices as your app will be smaller
- Make your code base easier to maintain through strict API boundaries and the benefits of namespacing
- Speed up linking and thus overall build time
Because the question will inevitably come up: we do not believe shared libraries will have any practical effect for LGPL users. There are other concerns that come into play with the Apple App Store (namely, DRM) which render the point moot. However, we recommend using shared libraries for the technical reasons outlined above. And as always, seek professional legal advice with regard to software licensing matters.Build System Enhancements
In the past several Qt releases we have also made a number of significant enhancements to the build system on Apple Platforms, including:
- @rpath in the install names of Qt libraries, providing relocatability out of the box (Qt 5.5)
- Standalone .dSYM debug symbols (Qt 5.6.1, Qt 5.6.2)
- Building asset catalogs (Qt 5.6.3 & Qt 5.7.1)
- Bitcode on iOS which allows Qt applications to take advantage of App Thinning (Qt 5.8)
- Precompiled headers on iOS, tvOS, and watchOS, reducing build time by up to 30% (Qt 5.8)
- Combined simulator and device builds, doing away with the confusing separate _simulator libraries on iOS (Qt 5.8)
- Multi-arch (“universal”) builds on macOS, back from Qt 4.x (coming in Qt 5.9)
- Automatically embedding Qt frameworks within a Qt app bundle in qmake-generated Xcode projects (coming in Qt 5.9)
- …and many other smaller bug fixes
One more thing… we’ve been changing every reference to “Mac OS X” and “OS X” that we can find into “macOS”.
Today the Kubuntu team is happy to announce that Kubuntu Zesty Zapus (17.04) is released today. With this Alpha 2 pre-release, you can see what we are trying out in preparation for 17.04, which we will be releasing in April.
NOTE: This is Alpha 2 Release. Kubuntu Alpha Releases are NOT recommended for:
* Regular users who are not aware of pre-release issues
* Anyone who needs a stable system
* Anyone uncomfortable running a possibly frequently broken system
* Anyone in a production environment with data or work-flows that need to be reliable
Getting Kubuntu 17.04 Alpha 2
* Upgrade from 16.10, run do-release-upgrade from a command line.
* Download a bootable image (ISO) and put it onto a DVD or USB Drive
I’ve got a chance to share a part of my upcoming book here. It is an excerpt from the second chapter.
The main feature of all functional programming languages is that functions can be treated like ordinary values. They can be saved into variables, put into collections and structures, passed to other functions as arguments, and also returned from other functions as results.
Functions that take other functions as arguments, or that return new functions are called higher-order functions. Higher-order functions is probably the most important concept in functional programming. As you might know, programs can be made more concise and efficient by describing what the program should do on a higher level, with the help of standard algorithms, instead of implementing everything by hand. Higher-order functions are indispensable for that. They allow us to define abstract behaviours and more complex control structures than those provided by the C++ programming language.
This week at work I published an article about the usage of C++ lambda expressions in Qt, hope you like it!
I usually don’t write political blog posts, especially if it relates to a country of which I’m not a citizen off nor live in. While I definitely have very clear opinions and views, I want to stay neutral in this blog and only talk about the technology side of things.
It seems that the new US administration is in the process of shaking-up a lot of traditions and regulations, while also redefining the relations between the USA and the rest of the world. Even though a lot of these changes are very relevant to a lot of people on this planet, I want to focus on three topics that directly affect the IT, the free software world and especially my work at Nextcloud.Crypto Wars and Backdoors
Some of you might remember the early times of the web in the 90s where we had the ‘crypto wars’. This was a time period where the US government tried to limit the access to strong cryptography, especially outside the US. The idea was that the US secret services should be able to crack and decrypt every encrypted communication that happens outside the US. For example software like PGP was not allowed to be exported outside of the US, and browsers like Netscape were only allowed to use weak 40Bit SSL keys while the US version supported 128Bit keys.
After a while the US realized that this was a very stupid idea and allowed other countries to also use strong encryption. It seems that the new Attorney General likes the idea of Crypto Backdoors and this is now back on the table. This would obviously be very bad for internet security. The EFF has a good summary.Legal battle over overseas Microsoft data
A lot of organisations and companies are concerned about storing sensitive data on servers and cloud services hosted in the USA. The reason is that the US government organisations are allowed to access all the information and data, and this is something a lot of people and companies don’t agree with. Microsoft and the ‘Deutsche Telekom’ have implemented a workaround, making it is possible to get an Microsoft Office 365 subscription where the data is hosted in a hosting center in Germany. The current judicial interpretation is that this service is covered by the local German law and not the US law.
However, now you can read in the news that it is possible that the US might soon have a different interpretation here. In the near future US agencies might have full access to services where US companies are involved, like in this case of Microsoft. More information can be found here in this article on politicoPrivacy Shield and Safe Harbor
Two days ago Trump signed an executive order which might kill the Privacy Shield agreement with the EU. This is an agreement which is the successor of Safe Harbor which basically allowed European based companies to use US based cloud services and still be compliant with EU law. If this agreement is being annulled, then this makes all data flow from the EU to US based cloud services illegal. More information from Techcrunch.
All this happened in only the last few days. It is not completely clear yet what the long term impact will be and what else might happen next, but it is safe to say that the security of computer systems, the internet and our privacy is under heavier attack than ever before.
Free software developers, organisations, companies and everyone else who cares about security and privacy should act now. We need to develop and support technology that implements strong cryptography and is distributed and federated. It is becoming very clear that the heavy dependency on US based IT, Cloud and web-services is not good for the rest of the world. One of the main benefits of free software like Linux, KDE, GNOME, ownCloud and Nextcloud is that everyone can host and install it wherever they want, can audit the code to make sure that there are no backdoors, while also being able to adapt it and enhance it however they want.
These are interesting times and we, as software developers, are in a key position to make sure that all people will have access to data privacy tools and secure communication in the future
It is pretty easy to install openSUSE Linux on a MacBook as operating system. However there are some pitfalls, which can cause trouble. The article gives some hints about a dual boot setup with OS X 10.10 and at time of writing current openSUSE Tumbleweed 20170104 (oS TW) on a MacBookPro from early 2015. A recent Linux kernel, like in TW, is advisable as it provides better hardware support.
The LiveCD can be downloaded from www.opensuse.org and written with ImageWriter GUI to a USB stick ~1GB. I’ve choose the Live KDE one and it run well on a first test. During boot after the first sound and display light switches on hold Option/alt key and wait for the disk selection icon. Put the USB key with Linux in a USB port and wait until the removable media icon appears and select it for boot. For me all went fine. The internal display, sound, touchpad and keyboard where detected and worked well. After that test. It was a good time to backup all data from the internal flash drive. I wrote a compressed disk image to a stick using the unix dd command. With that image and the live media I was able to recover, in case anything went wrong. It is not easy to satisfy OS X for it’s journaled HFS and the introduced logical volume layout, which comes with a separate repair partition directly after the main OS partition. That combination is pretty fragile, but should not be touched. The rescue partition can be booted with the command key + r pressed. External tools failed for me. So I booted into rescue mode and took the OS X diskutil or it’s Disk Utility GUI counter part. The tool allows to split the disk into several partitions. The EFI and the rescue ones are hidden in the GUI. The newly created additional partitions can be formatted to exfat and later be modified for the Linux installation. One additional HFS partition was created for sharing data between OS X and Linux with the comfortable Unix attributes. The well know exfat used by many bigger USB sticks, is a possible option as well, but needs the exfat-kmp kernel module installed, which is not by default installed due to Microsofts patent license policy for the file system. In order to write to HFS from Linux, any HFS partition must have switched off the journal feature. This can be done inside the OS X Disk Utility GUI, by selecting the data partition and holding the alt key and searching in the menu for the disable journaling entry. After rebooting into the Live media, I clicked on the Install icon on the desktop background and started openSUSE’s Yast tool. Depending on the available space, it might be a good idea to disable the btrfs filesystem snapshot feature, as it can eat up lots of disk space during each update. An other pitfall is the boot stage. Select there secure GrubEFI mode, as Grub needs special handling for the required EFI boot process. That’s it. Finish install and you should be able to reboot into Linux with the alt key.
My MacBook has unfortunedly a defect. It’s Boot Manager is very slow. Erasing and reinstalling OS X did not fix that issue. To circumvent it, I need to reset NVRAM by pressing alt+cmd+r+p at boot start for around 14 second, until the display gets dark, and can then fluently go through the boot process. Without that extra step, the keyboard and mouse might not respond in Linux at all, except the power button. Hot reboot from Linux works fine. OS X does a cold reboot and needs the extra sequence.
KDE’s Plasma needs some configuration to run properly on a high resolution display. Otherwise additional monitors can be connected and easily configured with the kscreen SystemSettings module. Hibernate works fine. Currently the notebooks SD slot is ignored and the facetime camera has no ready oS packages. Battery run time can be extended by spartan power consumption (less brightness, less USB devices and pulseaudio -k, check with powertop), but is not too far from OS X anyway.
While working on the Qt Visual Studio tools, I had to think about how to locally perform and test the update process for extensions. As already known to most Visual Studio users, the IDE provides a way to setup your own private extension gallery. To do so, one has to open the Visual Studio Tools | Options Dialog and create a new Additional Extension Gallery under Environment | Extensions and Updates.
My initial try was to simply put the generated VSIX into a folder on the disk and point the URL field to this folder. After looking at the Tools | Extensions and Updates dialog, no update was highlighted for the tools. Because this was not as easy as I had thought, so some configuration file probably needed to be provided. A short search on the Internet led to the following article – there we go, it turned out that the configuration file is based on the Atom feed format.
Visual Studio uses an extended version of the Atom feed format consisting of two parts, the Header and the Entry. The header needs to be provided only once, while the entry can be repeated multiple times. Lets take a look at the header tags:
<title> The repository name.
<id> The unique id of the feed.
<updated> The date/time when the feed was updated.
Please note that even though these tags do not seem to be important for the desired functionality, it still makes sense to keep them.
The more interesting part is the Entry tag that describes the actual package you’re going to share. There seem to be a lot of optional tags as well, so I’m just going to describe the most important one. To force an update of your package, simply put an <Vsix> inside the entry tag. It must contain two other tags:
<id> The id of your VSIX.
<version> The version of the VSIX.
As soon as you increase the version number, even without rebuilding the VSIX, Visual Studio will present you with an update notice of your package. For a more advance description of the tags possible, follow this link. If you are looking for the minimum Atom feed file to start with, you can grab a copy of ours here.
So now one might ask, why did I write all that stuff? Well, while I was preparing the next Qt Visual Studio Tools release I scratched my head quite a bit on this topic. And just maybe – it might save some other developer’s day while doing a Visual Studio extension release. Last but not least, I am happy to announce the availability of an updated version of the Qt Visual Studio Tools with the following improvements:
- Bug fixes
- Making it faster
- Using the new TextMate language files in Visual Studio 2015 SP3 for QML file and QMake project file syntax highlighting
The Qt Company has prepared convenient installers for the Qt Visual Studio Tools 2.1 release. You can download it from your Qt Account or from download.qt.io. They are also available from the Visual Studio Gallery for Visual Studio 2013 and Visual Studio 2015.
For any issues you may find with the release, please submit a detailed bug report to bugreports.qt.io (after checking for duplicates). You are also welcome to join the discussions in the Qt Project mailing lists, development forums and to contribute to Qt.