GNOME.ORG

24 hours a day, 7 days a week, 365 days per year...

October 01, 2014

Markdown Style Guide

Markdown is as a file format for easily producing text that can be pleasantly read both on the web and while using command line tools, or plain text editors.

Recently, a crop of tools have emerged that deliver some form of WYSIWYG or side-by-side authoring tools to assist writers to visualize the final output as they work.

Authors are turning to these tools to produce documentation that looks good when authoring the document, yet the tools are not true to the spirit and goals of markdown. And in some cases, authors are not familiar with the essence of what makes markdown great, nor the philosophy behind it:

Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it’s been marked up with tags or formatting instructions.

Using these editors is the modern equivalent of using Microsoft Word to produce HTML documentation.

The generated markdown files very easy to produce, but are not suitable for human consumption. They likely violate a number of international treaties and probably will be banned by the EU.

This short post is a set of simple rules to improve your markdown.

They will help you deliver delight to all of your users, not just those using a web browser, but also those casually reading your documentation with a file manager, their console, and most importantly, potential contributors and copy editors that have to interact with your text.

Wrap Your Text

The ideal reading length for reading prose with a monospaced font is somewhere between 72 and 78 characters.

This is text snippet is from Mark Twain's Adventures of Tom Sawyer, with text wrapped around column 72, when reading in an 80x25 console:

It wont matter if you are using a larger console, the text will still be pleasant to read.

But if you use some of these markdown editors that do not bother wrapping your text, this is what the user would get:

And this is what is more likely to happen, with big consoles on big displays:

There is a reason why most web sites set a maximum width for the places where text will be displayed. It is just too obnoxious to read otherwise.

Many text editors have the ability of reformatting text your text when you make changes.

This is how you can fill your text in some common editors:

  • Emacs: Alt-Q will reformat your paragraph.
  • Vim: "V" (to start selection) then "gq" will reformat your selection.
  • TextMate: Control-Q.

Considering Using Two Spaces After a Period

When reading text on the console, using two spaces after a period makes it easier to see where phrases end and start.

While there is some debate as to the righteouness of one vs two spaces in the word of advanced typography these do not apply to markdown text. When markdown is rendered into HTML, the browser will ignore the two spaces and turn it into one, but you will give your users the extra visual queues that they need when reading text.

If you are interested in the topic, check these posts by Heraclitean River and DitchWalk.

Sample Code

For small code snippets, it is best if you just indent your code with spaces, as this will make your console experience more pleasant to use.

Recently many tools started delimiting code with the "```". While this has its place in large chunks of text, for small snippets, it is the visual equivalent of being punched in the face.

Try to punch your readers in the face only when absolutely necessary.

Headers

Unless you have plans to use multiple-nested level of headers, use the underline syntax for your headers, as this is visually very easy to scan when reading on a console.

That is, use:

Chapter Four: Which iPhone 6 is Right For You.
==============================================

In the previous chapter we established the requirement to buy iPhones
in packs of six.  Now you must choose just whether you are going to go
for an apologetically aluminum case, or an unapologetically plastic
iPhone.
	

Instead of the Atx-style headers:

# Chapter Four: Which iPhone 6 is Right For You.
	

The second style can easily drown in a body of text, and can not help as a visual aid to see where new sections start.

Blockquotes

While markdown allows you to only set the first character for a blockquote, like this:

> his is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
	

Editors like Emacs, can reformat that text just fine, all you have to do is set the "Fill Prefix", by positioning your cursor after the "> " and use Control-x f, then you can use the regular fill command: Alt-Q, and this will produce:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere
> lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet
> vitae, risus.

Lists

Again, while Markdown will happily allow you to write things like:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.

You should love your reader, and once again, if you are using something like Emacs, use the fill prefix to render the list like this instead:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
    viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
    Suspendisse id sem consectetuer libero luctus adipiscing.	

Announcing California 0.2

yorba_logo_big1.pngI’m pleased to announce the release of California 0.2, Yorba’s GNOME 3 calendar application.  A lot has happened since we announced California (way back in March) and I’m happy to say that we got more features into this first release than I thought we’d make.  Version 0.2 offers the following:

  • Month and Week views of events
  • Add and remove Google, CalDAV, and webcal (.ics) calendars
  • Integrates with Evolution Data Server, so your existing Evolution calendars are automatically available
  • Add, view, edit, and remove events (including recurring events)
  • A natural-language Quick Add parser for easily adding events: just type in the information and California schedules the event(s)
  • F1 online help (thanks Jim Campbell!)
  • Smooth animations and popovers for viewing information effortlessly
California 0.2California 0.2

The California 0.2.0 tarball is available for download at https://download.gnome.org/sources/california/0.2/california-0.2.0.tar.xz

California is also available for Ubuntu Utopic (and its derivatives) at Yorba’s PPA.

September 30, 2014

GTK+ widget templates now in Javascript

Let's get the features in early!

If you're working on a Javascript application for GNOME, you'll be interested to know that you can now write GTK+ widget templates in gjs.

Many thanks to Giovanni for writing the original patches. And now to a small example:

const MyComplexGtkSubclass = new Lang.Class({
Name: 'MyComplexGtkSubclass',
Extends: Gtk.Grid,
Template: 'resource:///org/gnome/myapp/widget.xml',
Children: ['label-child'],

_init: function(params) {
this.parent(params);

this._internalLabel = this.get_template_child(MyComplexGtkSubclass,
'label-child');
}
});

And now you just need to create your widget:

let content = new MyComplexGtkSubclass();
content._internalLabel.set_label("My updated label");

You'll need gjs from git master to use this feature. And if you see anything that breaks, don't hesitate to file a bug against gjs in the GNOME Bugzilla.

September 29, 2014

Tiny C++ Benchmark Framework

Lately I had to improve a little some of my algorithms. I wanted to check, how changes affect to time of algorithms execution. So I started to search benchmark framework for C++. After a while, I have found quite small, but powerful framework - google benchmark [1].

Simple usage

The simplest usage of google benchmark is shown below:
#include <benchmark/benchmark.h>
#include <algorithm>

int complex_computation(int n)
{
  if (n == 0)
    return 0;

  unsigned int a = 1, b = 1;

  for (unsigned int i=0; i < n-1; i++)
    {
      std::swap(a, b);
      b += a;
    }

return b;
}

static void BM_Fibonacci(benchmark::State& state)
{
  int ret;

while (state.KeepRunning())
    ret |= complex_computation(500);

  CHECK(ret != 0);
}

BENCHMARK(BM_Fibonacci);

int main(int argc, const char* argv[])
{
  benchmark::Initialize(&argc, argv);
  benchmark::RunSpecifiedBenchmarks();

  return 0;
}
At the beginning, we have to define function, which will be measured (complex_computation, in my case). Next, we're defining benchmark method - BM_Fibonacci. It has one argument - state (I will talk about it later). In while loop we call our method, until benchmark's working. ret variable is used only because of compiler optimizations (we'd like to avoid removing dummy code). Benchmark method should be later registered (using BENCHMARK macro). In main function, framework should be initialized, and after that, we can run all our benchmark methods.
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ g++ benchmark.cpp -std=c++11 -lbenchmark -lpthread -O2 -o benchmark
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ ./benchmark
Reading /proc/self/cputime_ns failed. Using getrusage().
Benchmarking on 4 X 2701 MHz CPUs
2014/09/29-00:49:29
CPU scaling is enabled: Benchmark timings may be noisy.
DEBUG: Benchmark Time(ns) CPU(ns) Iterations
----------------------------------------------------
DEBUG: BM_Fibonacci 208 225 2222788
loganek@hf-gcs-computer:~/Documents/blog-benchmark$

As you can see, there is computation time, cpu and iterations count - everything what we need :) Moreover, we can also get a few informations about machine.

Arguments, range of arguments

Snippet shown above is very simple, but this framework offers users much more. We can define a set of arguments for benchmark. Let's remind previous example. We tried to measure fibonacci implementation. But I hardcoded an argument. Sometimes we'd like to measure one method with different arguments. We don't have to define BM_Fibonacci_5, BM_Fibonacci_42, BM_Fibonacci_87 functions for different arguments. Let's look at the improvement of previous code:
static void BM_Fibonacci(benchmark::State& state)
{
int ret;
while (state.KeepRunning())
ret |= complex_computation(state.range_x());
CHECK(ret != 0);
}

BENCHMARK(BM_Fibonacci)->Arg(5)->Arg(42)->Arg(87);
and the output is also quite different:
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ ./benchmark 
Reading /proc/self/cputime_ns failed. Using getrusage().
Benchmarking on 4 X 2701 MHz CPUs
2014/09/29-01:20:03
CPU scaling is enabled: Benchmark timings may be noisy.
DEBUG: Benchmark Time(ns) CPU(ns) Iterations
-------------------------------------------------------
DEBUG: BM_Fibonacci/5 3 19 25832109
DEBUG: BM_Fibonacci/42 18 35 14398500
DEBUG: BM_Fibonacci/87 44 61 8224413
We've access for results of every argument, which I passed to a benchmark method.
It is also possible to pass range of arguments to our benchmark method.
BENCHMARK(BM_Fibonacci)->Range(0, 1024);
Defined range runs benchmark for min, max in this range, and every power of 8 from this range. So in my case: 0, 1, 8, 64, 512 and 1024.

Multithreading, other features

Google Benchmark framework gives a few other features for developers:
  • multithreading
  • benchmark templates
  • pair of arguments
  • custom reporter class
You may see usage of other features in google benchmark example code [2] or on README page[3].

Summary

That's one of first test framework, which I used for now. Previously I wrote simple methods for measurements, but it wasn't so convenient, and in the long run, it's just waste of time. Moreover, benchmark helps me keep in order my tests, so my code is much cleaner than before.
In the future, I'd like to check also other frameworks; I heard about Celero [4] and hayai [5]. But for now, google benchmark fits my needs.



Links
[1] https://github.com/google/benchmark
[2] https://github.com/google/benchmark/blob/master/test/benchmark_test.cc
[3] https://github.com/google/benchmark/blob/master/README.md
[4] https://github.com/DigitalInBlue/Celero
[5] https://github.com/nickbruun/hayai

GNOME Boston Summit 2014

The Boston Summit is a 3-day hackfest for GNOME developers and contributors, that we traditionally hold over the Columbus day weekend.

In recent years, we’ve met in Montreal,  but for 2014,  we are back in Boston, at the MIT.

Early Turning

Details

When:    Saturday, October 11 — Monday, October 13
Where:  MIT building E51, Cambridge, MA

Topics

There’s plenty of topics we can discuss. Here are some I would be interested in working on:

  • Application development (bundling, SDKs, sandboxing, kdbus, …)
  • Wayland (porting leftovers, possibilities for the future, …)
  • Privacy

If you are interested, please let us know you’re coming.

Hope to see many old and new faces there !

summing up 62

i am trying to build a jigsaw puzzle which has no lid and is missing half of the pieces. i am unable to show you what it will be, but i can show you some of the pieces and why they matter to me. if you are building a different puzzle, it is possible that these pieces won't mean much to you, maybe they won't fit or they won't fit yet. then again, these might just be the pieces you're looking for. this is summing up, please find previous editions here.

  • capturing the upside, by clayton christensen. the notion here is that if you create a new business that tries to position itself at the point in a value chain where really attractive money is being made, by the time you get there it probably will have gone, and you can tell where it's gone in a very predictable way, and that's what i want to try to get at here. over on this side of the world, the money tends to be made by the company that designs the architecture, the system, that solves what is not good enough. because it's functionality and reliability that's not good enough, the company that makes this systems that is proprietary and optimized tends to be at the place where most of the profit in the industry is made. because the performance of that kind of a product isn't dictated by the individual components, of which it is comprised; this is determined at the level of the architecture of the system, and that is where the money is made. but on this side, when it becomes more than good enough and the architecture becomes modular, where the money is made flips to the inside of the product. how are you going to do this? anything you can do, the competitors can just copy instantly because in a nonintegrated word, you're outsourcing from a common supplier base, and when the architecture of the system is modular, and it fits together according to industry standards, the better products are not created through clever architectural design; the performance of the product is driven by what's inside. highly recommended
  • seth godin's startup school (transcript), in the summer of 2012 i had an amazing opportunity to spend three days with a group of extremely motivated entrepreneurs - people right at the beginning of building their project, launching their organization. during those three days i took them on a guided tour of some of the questions they were going to have to wrestle with, some of the difficult places they were going through to stand up and say, "this is me. this is what i'm making". highly recommended
  • snowden and the future, by eben moglen. when there is no collective voice for those who are within structures that deceive and oppress, then somebody has to act courageously on his own. someone has to face all the risk for a tiny share of the total benefit that will be reaped by all. such a man may be walking the pathway from slavery to freedom. but any such man worthy of the effort will know that he may also be digging his own grave. when there is no union, we require heroism. or we perish for want of what we should have known, that there was neither collective will nor individual courage to bring us. it takes a union to end slavery because a man who decides that the will of the righteous commands us to free slaves will be called a traitor, and they will hang him-more than once. highly recommended
  • frank sinatra's 1963 playboy interview, i think i can sum up my religious feelings in a couple of paragraphs. first: i believe in you and me. i'm like albert schweitzer and bertrand russell and albert einstein in that i have a respect for life - in any form. i believe in nature, in the birds, the sea, the sky, in everything i can see or that there is real evidence for. if these things are what you mean by god, then i believe in god. but i don't believe in a personal god to whom i look for comfort or for a natural on the next roll of the dice. i'm not unmindful of man's seeming need for faith; i'm for anything that gets you through the night, be it prayer, tranquilizers or a bottle of jack daniel's. but to me religion is a deeply personal thing in which man and god go it alone together, without the witch doctor in the middle. the witch doctor tries to convince us that we have to ask god for help, to spell out to him what we need, even to bribe him with prayer or cash on the line. well, i believe that god knows what each of us wants and needs. it's not necessary for us to make it to church on sunday to reach him. you can find him anyplace. and if that sounds heretical, my source is pretty good: matthew, five to seven, the sermon on the mount

Shipping larger application icons in Fedora 22

In GNOME 3.14 we show any valid application in the software center with an application icon of 32×32 or larger. Currently a 32×32 icon has to be padded with 16 pixels of whitespace on all 4 edges, and also has to be scaled x2 to match other UI elements on HiDPI screens. This looks very fuzzy and out of place and lowers the quality of an otherwise beautiful installing experience.

For GNOME 3.16 (Fedora 22) we are planning to increase the minimum icon size to 48×48, with recommended installed sizes of 16×16, 24×24, 48×48, 64×64, 256×256 (or SVG in some cases). Modern desktop applications typically ship multiple sizes of icons in known locations, and it’s very much the minority of applications that only ship one small icon.

Soon I’m going to start nagging upstream maintainers to install larger icons than 32×32. If you’re re-doing the icon, please generate a 256×256 or 64×64 icon with alpha channel, as the latter will probably be the minimum size for F23 and beyond.

At the end of November I’ll change the minimum icon size in the AppStream generator used for Fedora so that applications not fixed will be dropped from the metadata. You can of course install the applications manually on the command line, but they won’t be visible in the software center until they are installed.

If you’re unclear on what needs to be done in order to be listed in the AppStream metadata, refer to the guidelines or send me email.

Highlights in Grilo 0.2.11 (and Plugins 0.2.13)

Hello, readers!

Some weeks ago we released a new version of Grilo and the Plugins set (yes, it sounds like a 70′s music group :) ). You can read the announcement here and here. If you are more curious about all the detailed changes done, you can take a look at the Changelog here and here.

But even when you can read that information in the above links, it is always a pleasure if someone highlights what are the main changes. So let’s go!

Launch Tool

Regarding the core system, among the typical bug fixes, I would highlight a new tool: grl-launch. This tool, as others, got inspiration from GStreamer gst-launch. So far, when you wanted to do some operation in Grilo, like performing a search in YouTube or getting the title of a video on disk, the recommended way was using Grilo Test UI. This is a basic application that allows you to perform the typical operations in Grilo, like browsing or searching, and everthing from a graphical interface. The problem is that this tool is not flexible enough, so you can’t control all the details you could require. And it is also useful to visually check the results, but not to export the to manage with another tool.

So while the Test UI is still very useful, to cover the other cases we have grl-launch. It is a command-line based tool that allows you to perform most of the operations allowed in Grilo, with a great degree of control. You can browse, search, solve details from a Grilo media element, …, with a great control: how many elements to skip or return, the metadata keys (title, author, album, …) to retrieve, flags to use, etc.

And on top of that, the results can be exported directly to a CSV file so it can be loaded later in a spreadsheet.

As example, getting the 10 first trailers from Apple’s iTunes Movie Trailers site:

$ grl-launch-0.2 browse -c 10 -k title,url grl-apple-trailers
23 Blast,http://trailers.apple.com/movies/independent/23blast/23blast-tlr_h480p.mov
A Most Wanted Man,http://trailers.apple.com/movies/independent/amostwantedman/amostwantedman-tlr1_h480p.mov
ABC's of Death 2,http://trailers.apple.com/movies/magnolia_pictures/abcsofdeath2/abcsofdeath2-tlr3_h480p.mov
About Alex,http://trailers.apple.com/movies/independent/aboutalex/aboutalex-tlr1b_h480p.mov
Addicted,http://trailers.apple.com/movies/lionsgate/addicted/addicted-tlr1_h480p.mov
"Alexander and the Terrible, Horrible, No Good, Very Bad Day",http://trailers.apple.com/movies/disney/alexanderterribleday/alexanderterribleday-tlr1_h480p.mov
Annabelle,http://trailers.apple.com/movies/wb/annabelle/annabelle-tlr1_h480p.mov
Annie,http://trailers.apple.com/movies/sony_pictures/annie/annie-tlr2_h480p.mov
Are You Here,http://trailers.apple.com/movies/independent/areyouhere/areyouhere-tlr1_h480p.mov
As Above / So Below,http://trailers.apple.com/movies/universal/asabovesobelow/asabovesobelow-tlr1_h480p.mov
10 results

As said, if you re-direct the output to a file and you import it from a spreadsheet program as CSV you will read it better.

dLeyna/UPnP plugin

Regarding the plugins, here is where the fun takes place. Almost all plugins were touched, in some way or other. In most cases, for fixing bugs. But there are other changes I’d like to highlight. And among them, UPnP is one that suffered biggest changes.

Well, strictly speaking, there is no more UPnP plugin. Rather, it was replaced by new dLeyna plugin, written mainly by Emanuele Aina. From an user point of view, there shouldn’t be big differences, as this new plugin also provides access to UPnP/DLNA sources. So where are the differences?

First off, let’s specify what is dLeyna. So far, if you want to interact with a UPnP source, either you need to deal with the protocol, or use some low-level library, like gupnp. This is what the UPnP plugin was doing. Still it is a rather low-level API, but higher and better than dealing with the raw protocol.

On the other hand, dLeyna, written by the Intel Open Source Technology Center, wraps the UPnP sources with a D-Bus layer. Actually,not only sources, but also UPnP media renderers and controllers, though in our case we are only interested in the UPnP sources. Thanks to dLeyna, you don’t need any more to interact with low-level UPnP, but with a higher D-Bus service layer. Similar to the way we interact with other services in GNOME or in other platforms. This makes easier to browser or search UPnP sources, and allows us to add new features. dLeyna also hides some details specific to each UPnP server that are of no interest for us, but we would need to deal with in case of using a lower level API. The truth is that though UPnP is quite well specified, each implementation doesn’t follow it at 100%: there are always slight differences that create nasty bugs. In this case, dLeyna acts (or should act) as a protection, dealing itself with those differences.

And what is needed to use this new plugin? Basically, having dleyna-service D-Bus installed. When the plugin is started, it wakes up the service, which will expose all the available UPnP servers in the network, and the plugin would expose them as Grilo sources. Everything as it was happening with the previous UPnP source.

In any case, I still keep a copy of the old UPnP plugin for reference, in case someone want to use it or take a look. It is in “unmaintained” mode, so try to use the new dLeyna plugin instead.

Lua Factory plugin

There isn’t big changes here, except fixes. But I want to remark it here because it is where most activity is happening. I must thank Bastien and Victor for the work they are doing here. Just to refresh, this plugin allows to execute sources written in Lua. That is, instead of writing your sources in GObject/C, you can use Lua. The Lua Factory plugin will load and run them. Writing plugins in Lua is a pleasure, as it allows to focus on fixing the real problems and leave the boiler plate details to the factory. Honestly, if you are considering writing a new source, I would really think about writing it in Lua.

And that’s all! It is a longer post than usual, but it is nice to explain what’s going on in Grilo. And remember, if you are considering using Grilo in your product, don’t hesitate to contact with us.

Happy week!

September 28, 2014

Tiny C++ Benchmark Framework

Lately I had to improve a little some of my algorithms. I wanted to check, how changes affect to time of algorithms execution. So I started to search benchmark framework for C++. After a while, I have found quite small, but powerful framework - google benchmark [1].

Simple usage

The simplest usage of google benchmark is shown below:
#include <benchmark/benchmark.h>
#include <algorithm>

int complex_computation(int n)
{
  if (n == 0)
    return 0;

  unsigned int a = 1, b = 1;

  for (unsigned int i=0; i < n-1; i++)
    {
      std::swap(a, b);
      b += a;
    }

return b;
}

static void BM_Fibonacci(benchmark::State& state)
{
  int ret;

while (state.KeepRunning())
    ret |= complex_computation(500);

  CHECK(ret != 0);
}

BENCHMARK(BM_Fibonacci);

int main(int argc, const char* argv[])
{
  benchmark::Initialize(&argc, argv);
  benchmark::RunSpecifiedBenchmarks();

  return 0;
}
At the beginning, we have to define function, which will be measured (complex_computation, in my case). Next, we're defining benchmark method - BM_Fibonacci. It has one argument - state (I will talk about it later). In while loop we call our method, until benchmark's working. ret variable is used only because of compiler optimizations (we'd like to avoid removing dummy code). Benchmark method should be later registered (using BENCHMARK macro). In main function, framework should be initialized, and after that, we can run all our benchmark methods.
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ g++ benchmark.cpp -std=c++11 -lbenchmark -lpthread -O2 -o benchmark
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ ./benchmark
Reading /proc/self/cputime_ns failed. Using getrusage().
Benchmarking on 4 X 2701 MHz CPUs
2014/09/29-00:49:29
CPU scaling is enabled: Benchmark timings may be noisy.
DEBUG: Benchmark Time(ns) CPU(ns) Iterations
----------------------------------------------------
DEBUG: BM_Fibonacci 208 225 2222788
loganek@hf-gcs-computer:~/Documents/blog-benchmark$

As you can see, there is computation time, cpu and iterations count - everything what we need :) Moreover, we can also get a few informations about machine.

Arguments, range of arguments

Snippet shown above is very simple, but this framework offers users much more. We can define a set of arguments for benchmark. Let's remind previous example. We tried to measure fibonacci implementation. But I hardcoded an argument. Sometimes we'd like to measure one method with different arguments. We don't have to define BM_Fibonacci_5, BM_Fibonacci_42, BM_Fibonacci_87 functions for different arguments. Let's look at the improvement of previous code:
static void BM_Fibonacci(benchmark::State& state)
{
int ret;
while (state.KeepRunning())
ret |= complex_computation(state.range_x());
CHECK(ret != 0);
}

BENCHMARK(BM_Fibonacci)->Arg(5)->Arg(42)->Arg(87);
and the output is also quite different:
loganek@hf-gcs-computer:~/Documents/blog-benchmark$ ./benchmark 
Reading /proc/self/cputime_ns failed. Using getrusage().
Benchmarking on 4 X 2701 MHz CPUs
2014/09/29-01:20:03
CPU scaling is enabled: Benchmark timings may be noisy.
DEBUG: Benchmark Time(ns) CPU(ns) Iterations
-------------------------------------------------------
DEBUG: BM_Fibonacci/5 3 19 25832109
DEBUG: BM_Fibonacci/42 18 35 14398500
DEBUG: BM_Fibonacci/87 44 61 8224413
We've access for results of every argument, which I passed to a benchmark method.
It is also possible to pass range of arguments to our benchmark method.
BENCHMARK(BM_Fibonacci)->Range(0, 1024);
Defined range runs benchmark for min, max in this range, and every power of 8 from this range. So in my case: 0, 1, 8, 64, 512 and 1024.

Multithreading, other features

Google Benchmark framework gives a few other features for developers:
  • multithreading
  • benchmark templates
  • pair of arguments
  • custom reporter class
You may see usage of other features in google benchmark example code [2] or on README page[3].

Summary

That's one of first test framework, which I used for now. Previously I wrote simple methods for measurements, but it wasn't so convenient, and in the long run, it's just waste of time. Moreover, benchmark helps me keep in order my tests, so my code is much cleaner than before.
In the future, I'd like to check also other frameworks; I heard about Celero [4] and hayai [5]. But for now, google benchmark fits my needs. 



Links
[1] https://github.com/google/benchmark
[2] https://github.com/google/benchmark/blob/master/test/benchmark_test.cc
[3] https://github.com/google/benchmark/blob/master/README.md
[4] https://github.com/DigitalInBlue/Celero
[5] https://github.com/nickbruun/hayai

Underwater Wheelchair

Diving about is probably the closest imaginable experience to what it must seem like to people going into space. Going into space is not likely to be same as diving, of course. The atmosphere underwater is pretty dense. But space exploration seems analogous to diving in the sense that it puts us in an environment which means it is no longer possible to interact with our surroundings in the ways we take for granted, as normal.

The whole thing can be quite disorientating and unfortunately  for various reasons, there are a lot of health restrictions on diving so not everyone is allowed to have a go. The following video shows an adapted underwater wheelchair in action...

Video Not enabled. View now

 Technology breaking barriers, again: Very cool!

[gnome] LibreOffice Con in Bern, Switzerland

I was invited to give a talk in Bern, Switzerland, for the LibreOffice Conference. The LibreOffice people are a nice crowd with diverse backgrounds. I talked to design people, coders doing rather low-level GL things, marketing folks, some being new to Free Software, and to some being old farts. It sounds like a lot of […]

Keiser Report: Bitcoin Fight Night... Hilarious!

I do not know how I missed this comedy gold in April but on the off-chance others missed it too, I thought I would share so that others may bask in the gold.

Bare with it, things hot up about half the way through:

Video is not supported.

I still have tears in my eyes as I write this... Watch it if you haven't already!

Sorry, I don't have a transcript for this so I can't share that. In any case if you can click on the subtitles link on the bottom right to see subtitles of the show.


September 27, 2014

GNOME 3 and HIG Love

I am making progress on the next Ekiga release. I have spent the last few months of spare time working on the user interface. The purpose is to adapt the UI and use the great GTK+3 features when adequate. There is still much left to do, but here are before and after screenshots. Stay tuned […]

September 26, 2014

The Continuing Adventures (Transitioning From Intern To Volunteer)

2014 WikiConference USA (Group F) 25 By now dozens of women have stepped into open source via Outreach Program for Women, a paid internship program administered by the GNOME Foundation. I recently asked several of them whether they had been able to transition from intern to volunteer.*

Are you succeeding at continuing to volunteer in your open source project? Or are you running into trouble? I'd love to know how people are doing and whether y'all need help.

When you were an OPW intern, you had a mentor and you had committed to a specific project for three months. Volunteering is freer -- you can change your focus every week if you want -- but the training wheels are gone and you have to steer yourself.

(I bet Google Summer of Code alumni have similar experiences.)

I got several answers, and in them I saw some common problems to which I suggest solutions.

  1. Problem: seems as though there are no more specific tasks to do within your project. Solutions: ask your old mentor what they might like you to do next. If they don't respond within 3 days, repeat your question to the mailing list for your open source project. Or switch to another open source project, maybe one your friends are working on!

  2. OPW mentors and interns at Wiki Conference USA 2014 Problem: finding the time. Solutions: set aside a weekly appointment, just as you might with a therapist or an exercise class. Pair up with someone else from the OPW alum list and set yourself a task to complete during a one-hour online sprint! Or if you know your time is being eaten up by your new job, set yourself a reminder for 3 months from now to check whether you have more free time in December.

  3. Problem: loneliness. Solutions: talk more in the #opw chat channel on GNOME's IRC (irc.gnome.org). Use http://www.pairprogramwith.me/ and http://lanyrd.com/ and https://lwn.net/Calendar/ to find get-togethers in your area, or launch one using http://hackdaymanifesto.com/ and http://meetup.com/.

  4. Karen Sandler, GNOME and OPW advocate. Problem: motivation. Solutions: consider the effects you're having in the world. Or focus on the bits of work you enjoy for their own sake, whatever those are. Or teach others the things you know, and see the light spark in their eyes.

These are tips for the graduating interns themselves; it would be good for someone, maybe me, to also write a list of tips for the organizers and mentors to nurture continued participation.


* OPW also provides a list of paid opportunities for alumni.

IRS Tax-Exempt Status & FaiF 0x4E

Historically, I used to write a blog post for each episode of the audcast, Free as in Freedom that Karen Sandler and I released. However, since I currently do my work on FaiF exclusively as a volunteer, I often found it difficult to budget time for a blog post about each show.

However, enough happened in between when Karen and I recorded FaiF 0x4E and when it was released earlier this week that I thought I'd comment on those events.

First, with regard to the direct content of the show, I've added some detail in the 0x4E show notes about additional research I did about various other non-software-related non-profit organizations that I mention in the show.

The primary thrust of Karen's and my discussion on the show, though, regarded how the IRS is (somewhat strangely) the regulatory body for various types of organizational statuses, and that our legislation lumps many disparate activities together under the term “non-profit organizations” in the USA. The types of these available, outlined in 26 USC§501(c), vary greatly in what they do, and in what the IRS intends for them to do.

Interestingly, a few events occurred in mainstream popular culture since FaiF 0x4E's recording that relate to this subject. First, on John Oliver's Last Week Tonight Episode 18 on 2014-09-21 (skip to 08:30 in the video to see the part I'm commenting on), John actually pulled out a stack of interlocking Form 990s from various related non-profit organizations and walked through some details of misrepresentation to the public regarding the organization's grant-making activities. As an avid reader of Form 990s, I was absolutely elated to see a popular comic pundit actually assign his staff the task of reviewing Form 990s to follow the money. (Although I wish he hadn't wasted the paper to print them out merely to make a sight gag.)

Meanwhile, the failure of just about everyone to engage in such research remains my constant frustration. I'm often amazed that people judge non-profit organizations merely based on a (Stephen-Colbert-style) gut reaction of truthiness rather than researching the budgetary actions of such organizations. Given that tendency, the mandatory IRS public disclosures for all these various non-profits end up almost completely hidden in plain sight.

Granted, you sometimes have to make as many as three clicks, and type the name of the organization twice on Foundation Center's Form 990 finder to find these documents. That's why I started to maintain the FLOSS Foundation gitorious repository of Form 990s of all the orgs related to Open Source and Free Software — hoping that a git cloneable solution would be more appealing to geeks. Yet, it's rare that anyone besides those of us who maintain the repository read these. The only notable exception is Brian Proffitt's interesting article back in March 2012, which made use of FLOSS Foundation Form 990 data. But, AFAIK, that's the only time the media has looked at any FLOSS Foundations' Form 990s.

The final recent story related to non-profits was linked to by Conservancy Board of Directors member, Mike Linksvayer on identi.ca. In the article from Slate Mike references there, Jordan Weissmann points out that the NFL is a 501(c)(6). Weissmann further notes that permission for football to be classified under 501(c)(6) rules seems like pork barrel politics in the first place.

These disparate events — the Tea Party attacks against IRS 501(c)(4) denials, John Oliver's discussion of the Miss America Organization, Weissmann's specific angle in reporting the NFL scandals, and (more parochially) Yorba's 501(c)(3) and OpenStack Foundation's 501(c)(6) application denials — are brief moments of attention on non-profit structures in the USA. In such moments, we're invited to dig deeper and understand what is really going on, using public information that's readily accessible. So, why do so many people use truthiness rather than data to judge the performance and behavior of non-profit organizations? Why do so many funders, grant-makers and donors admit to never even reading the Form 990 of the organizations whom they support and with whom they collaborate? I ask, of course, rhetorically, but I'd be delighted if there is any answer beyond: “because they're lazy”.

Copr Repository for Builder

Mathieu Bridon has been kind enough to setup a Builder repository in Fedora Copr for those that want to try things without building from source. This requires either a Fedora 21 system (currently in Alpha) or rawhide due to our requirement for Gtk+ 3.14.

No guarantees that I wont break things occasionally, but it's a start!

File bugs here.

September 25, 2014

Builder Progress Update

I've been hacking away like crazy since my last update. So much so that occasionally I forget to leave the house. Focus has still been primarily on the editor, since that is where I'll be spending most of my time during the day.

Auto Indentation for C

It's no secret the first language I'm focusing on is C. This is both because I really enjoy C and that I want it to write Builder in Builder. An added benefit is that a lot of other curly braced languages can reuse some of this code (eventually).

If you take a look at how VIM does auto-indention, you'll quickly come across a 3,000 LOC C function with a couple thousand lines of accessory code. What I've put together for Builder isn't quite as robust yet nor is it as configurable. But we will get there eventually. The main insight from the VIM code is how you walk backwards to discover your context. This is how the indention is performed here as well. (I'd like to change how this works eventually to use a very relaxed tokenizer, but that will have to come later).

Right now, this is only really tested with GNU style C (some people love, many people hate). Eventually I'll get to fixing it for more generic formats like K&R. If you file bugs, it will allow me to be more surgical with my time.

The C auto-indenter currently tries to handle:

  • Spacing after newlines within a given scope.
  • Indentation before and after of for, if, else, else if, switch, case an goto labels.
  • Upon the trailing ) in a function declaration, the arguments will be reformatted to GNOME style where the Type, *, and names are each aligned. This saves me so much time.
  • Newline after , automatically places you at the correct offset for a function call, declaration, etc.
  • If we want space before ( in function calls or declarations, automatically add it if not typed.
  • Automatically adding * at the beginning of the line in multi-line comments.
  • Closing comments when the first character on a multi-line comment is /.

There is still a lot more to do here, but I'm generally pretty pleased with using it so far. The corner cases are where things get complex, but I'm progressing.

Here is a short example of auto-formatting function parameter lists.

Change Tracking

In previous prototypes, I relied on git diff --minimal to tell me what has changed in the editor. This was handy because it was always correct with what the git commit will see. However, it resulted in lots of subprocesses being created that in my opinion are unnecessary. You also end up implementing anti-hysteresis so you don't shell out too often.

I made a gadget that listens to events from the GtkTextBuffer and tracks the state internally. Then we use a custom GtkSourceGutterRenderer in to render the changes in the gutter of the GtkSourceView.

There are essentially four states, each with slightly different rendering in the gutter.

  • No Change
  • Added
  • Changed
  • Added or Changed, but Saved.

Representing deleted ranges is a bit tougher to both track and render in a useful way, so it's not high on my priority list.

Editor Movements

Don't worry, keybindings will be configurable, although currently you need to edit src/resources/keybindings/default.ini.

  • <Control>E scrolls downwards in the editor.
  • <Control>Y scrolls upwards in the editor.
  • <Control>L selects the current line.
  • <Control>Home jumps to the beginning of the buffer.
  • <Control>End jumps to the end of the buffer.

All default accelerator choices are up for debate. Although I'll probably wait to have that debate until a lot more of the system is implemented.

Markdown Preview

There is a live markdown preview now when you are editing a markdown file. <Control><Alt>P will bring up the split-view with HTML preview. Currently this is using a modified GsMarkdown from GNOME Software. It was purpose driven so lacks some of the features we will need to support. I hope to move to CommonMark in the future for this.

One slightly annoying thing about this for large documents is that every edit causes the preview to scroll back to the top of the file. I'd like to see that change but requires some plumbing to track the cursor position in the output HTML.

Global Navigation

I just landed the framework for global navigation. VIM users are likely familiar with the <Control>O and <Control>I sequence to move to your last save point. Builder does the same (with the same key combo for now). However, where this get's interesting is that any workspace within Builder will be able to use this global navigation. That means you can jump between the documentation you last read and where you are editing a file with a single keystroke.

Eventually, this is going to be one of the core features that makes Builder a pleasure to use. I anticipate it will go through lots of refinement as we figure out what that is.

Trim Trailing Space

Just a small tool to remove trailing space from the editor. Sébastien Wilmet had a great idea of only trimming modified lines when saving the buffer. This would help avoid those pesky patches that change half the file every time you save. Some time needs to be spent thinking about the right way to plumb this.

AppStream Progress in September

Last time I blogged about AppStream I announced that over 25% of applications in Fedora 21 were shipping the AppData files we needed. I’m pleased to say in the last two months we’ve gone up to 45% of applications in Fedora 22. This is thanks to a lot of work from Ryan and his friends, writing descriptions, taking screenshots and then including them in the fedora-appstream staging repo.

So fedora-appstream doesn’t sound very upstream or awesome. This week I’ve sent another 39 emails, and opened another 42 bugs (requiring 17 new bugilla/trac/random-forum accounts to be opened). Every single file in the fedora-appstream staging repo has been sent upstream in one form or another, and I’ve been adding an XML comment to each one for a rough audit log of what happened where.

Some have already been accepted upstream and we’re waiting for a new tarball release; when that happens we’ll delete the file from fedora-appstream. Some upstreams are really dead, and have no upstream maintainer, so they’ll probably languish in fedora-appstream until for some reason the package FTBFS and gets removed from the distribution. If the package gets removed, the AppData file will also be deleted from fedora-appstream.

Also, in the process I’ve found lots of applications which are shipping AppData files upstream, but for one reason or another are not being installed in the binary rpm file. If you had to tell me I was talking nonsense in an email this week, I apologize. For my sins I’ve updated over a dozen packages to the latest versions so the AppData file is included, and fixed a quite a few more.

Fedora 22 is on track to be the first release that mandates AppData files for applications. If upstream doesn’t ship one, we can either add it in the Fedora package, or in fedora-appstream.

The bash vulnerability and Docker containers

In a previous post about Docker, I happened to randomly pick bash as a package shared between the host and containers. I had thought of it as a relatively innocent package, but the choice turned out to be prescient.  The bash vulnerability announced today shows just how important even those apparently innocent packages can be.

The truth is that whenever you run code, you need to have an understanding of who’s responsible for it over time. With the Project Atomic model for software delivery, we are also responsible for providing a base image from the upstream distribution, and that base image includes security updates. Are your application vendors on top of bash security updates? It will be interesting to see how rapidly public application containers are updated.

To me, a key goal of Atomic is making use of the flexibility and power of containers – while retaining the benefits of the maintenance model of trusted distributions, and this bash vulnerability shows why that’s important.


September 24, 2014

GNOME 3.14 – The movie

Video time!
https://www.youtube.com/watch?v=7p8Prlu3owc
09-24-release-vid-snapshot

3.14 is out and holy gnome it is awesome. Even though I came under a bit of a time pressure in the end, it has been such a pleasure to create a video surrounding this release. I’d like to thank GNOME Foundation and Alexander Larsson for providing me the Chromebook pixel, which made room for some awesome animations this cycle. Furthermore, Karen Sandler and her husband Mike has once again created an outstanding voice-over, taking the video to a whole new level. Lastly, the GNOME Design team deserves huge credit for all the assets I use in my videos. Making them myself would take have taken me ages!

Do come with feedback. I’d be particularly interested in your thoughts on the new animation experiments I’m making. Happy release day!

What’s new in GNOME Software 3.14

We have been working hard over the past 6 months to make GNOME Software even better compared to the previous 3.12 release. Here’s a quick status update what the new 3.14 release brings.

Refined front page

Thanks to the design help from Allan Day and Lapo Calamandrei, we’ve made a number of improvements to the front page:

gnome-software-3.14-overview

Improved update experience

  • We’ve landed redesigns for reviewing previously installed updates, which are now shown in a separate dialog.
  • It turned out that a lot of people were unhappy by too frequent update notifications, and we’ve listened: the notifications are now much less frequent. Security updates are time critical, and to make sure those get installed, GNOME Software nags daily. Other updates are now offered once a week, or you can opt to install them earlier through the GNOME Shell shutdown dialog at a convenient time, if you are rebooting / shutting down anyway.
  • Update details now include the full package version when you click on an update. Again, a much requested feature by power users who want to know what they are installing.
  • The updates page now shows the time when updates were last checked.
  • It’s now possible to disable the background update checks altogether through a hidden setting: ‘gsettings set org.gnome.software download-updates false’

Application add-ons

No need to go back to using command line tools to install plugin for popular apps. They are all now available through GNOME Software in the app details page:

 Usability testing

Jim Hall recently published the results for the usability tests he conducted as part of his Master’s program. One of the four apps tested was GNOME Software. We’ve looked through the issues pointed out and have already done a number of changes to take the usability research into account.

New first run dialog which explains what the app does:

Moved the Install / Remove buttons down from the headerbar to a more prominent position:

gnome-software-3.14-app-details

Support for Arch and Debian and openSUSE

It’s no longer just Fedora where GNOME Software is supported! Richard has done a lot of work this cycle to make it possible to run GNOME Software on other distros besides Fedora. Stay tuned; a number of distros are going to ship GNOME Software this fall / winter.

500 papercuts and countless bug fixes

I am exaggerating here a bit and it is actually not 500 papercuts fixed, but it is still a TON of small issues fixed, hopefully making the overall experience much nicer.

We’ve also had some very nice fixes (THANKS!!!) from people who don’t regularly work on gnome-software. To point out some:

  • Find-as-your-type search by Elad Alfassa
  • New icons for the high contrast accessibility theme by Andreas Nilsson
  • Dogtail UI tests by Martin Simon

Fedora Workstation

GNOME Software is set to be the software installer in the upcoming Fedora 21 Workstation release and Richard and I both have been focusing a lot on making it work really well on Fedora.

  • Fedora has nearly 45% of the apps now covered with appdata, thanks to the huge amount of work that Richard Hughes and Ryan Lerch and Máirín Duffy and all the rest of the Fedora contributors have put into this. But do not mistake this as a Fedora Workstation-only feature; it will also benefit Fedora’s KDE spin for having high quality app descriptions and screenshots. And it will also benefit all the rest of the distros since we’ve tried to get most of the appdata included upstream.
  • A lot of improvement have landed in the stack surrounding GNOME Software. PackageKit in Fedora 21 now uses the hif backend based on the libraries from the DNF project, making the GNOME Software experience much much smoother than with the previous PackageKit yum backend. This is a huge step forward compared to what we shipped in Fedora 20.
  • Once Richard’s work to include repository metadata on the Workstation install media lands, it should make the first launch experience much better by removing the need to wait while the metadata is downloaded.

If you have free time and want to help out GNOME Software, install Fedora 21 Alpha Workstation and give GNOME Software a try and report any bugs you can find. All feedback and bug reports are invaluable and highly appreciated.

Thanks everyone and hope you’ll enjoy GNOME Software 3.14!

GNOME 3.14 impressions

As part of the release preparation, I’ve done some smoketesting of GNOME 3.14 – looking good! As I usually do, I’ve taken some screenshots while testing things, to share some impressions. Screenshot from 2014-09-24 07:50:18-smallScreenshot from 2014-09-24 09:25:44-smallScreenshot from 2014-09-24 07:30:42-smallNow back to final release preparations.

My free software will respect users or it will be bullshit

I had dinner with a friend this evening and ended up discussing the FSF's four freedoms. The fundamental premise of the discussion was that the freedoms guaranteed by free software are largely academic unless you fall into one of two categories - someone who is sufficiently skilled in the arts of software development to examine and modify software to meet their own needs, or someone who is sufficiently privileged[1] to be able to encourage developers to modify the software to meet their needs.

The problem is that most people don't fall into either of these categories, and so the benefits of free software are often largely theoretical to them. Concentrating on philosophical freedoms without considering whether these freedoms provide meaningful benefits to most users risks these freedoms being perceived as abstract ideals, divorced from the real world - nice to have, but fundamentally not important. How can we tie these freedoms to issues that affect users on a daily basis?

In the past the answer would probably have been along the lines of "Free software inherently respects users", but reality has pretty clearly disproven that. Unity is free software that is fundamentally designed to tie the user into services that provide financial benefit to Canonical, with user privacy as a secondary concern. Despite Android largely being free software, many users are left with phones that no longer receive security updates[2]. Textsecure is free software but the author requests that builds not be uploaded to third party app stores because there's no meaningful way for users to verify that the code has not been modified - and there's a direct incentive for hostile actors to modify the software in order to circumvent the security of messages sent via it.

We're left in an awkward situation. Free software is fundamental to providing user privacy. The ability for third parties to continue providing security updates is vital for ensuring user safety. But in the real world, we are failing to make this argument - the freedoms we provide are largely theoretical for most users. The nominal security and privacy benefits we provide frequently don't make it to the real world. If users do wish to take advantage of the four freedoms, they frequently do so at a potential cost of security and privacy. Our focus on the four freedoms may be coming at a cost to the pragmatic freedoms that our users desire - the freedom to be free of surveillance (be that government or corporate), the freedom to receive security updates without having to purchase new hardware on a regular basis, the freedom to choose to run free software without having to give up basic safety features.

That's why projects like the GNOME safety and privacy team are so important. This is an example of tying the four freedoms to real-world user benefits, demonstrating that free software can be written and managed in such a way that it actually makes life better for the average user. Designing code so that users are fundamentally in control of any privacy tradeoffs they make is critical to empowering users to make informed decisions. Committing to meaningful audits of all network transmissions to ensure they don't leak personal data is vital in demonstrating that developers fundamentally respect the rights of those users. Working on designing security measures that make it difficult for a user to be tricked into handing over access to private data is going to be a necessary precaution against hostile actors, and getting it wrong is going to ruin lives.

The four freedoms are only meaningful if they result in real-world benefits to the entire population, not a privileged minority. If your approach to releasing free software is merely to ensure that it has an approved license and throw it over the wall, you're doing it wrong. We need to design software from the ground up in such a way that those freedoms provide immediate and real benefits to our users. Anything else is a failure.

(title courtesy of My Feminism will be Intersectional or it will be Bullshit by Flavia Dzodan. While I'm less angry, I'm solidly convinced that free software that does nothing to respect or empower users is an absolute waste of time)

[1] Either in the sense of having enough money that you can simply pay, having enough background in the field that you can file meaningful bug reports or having enough followers on Twitter that simply complaining about something results in people fixing it for you

[2] The free software nature of Android often makes it possible for users to receive security updates from a third party, but this is not always the case. Free software makes this kind of support more likely, but it is in no way guaranteed.

comment count unavailable comments

September 23, 2014

2014-09-23: Tuesday

  • Mail chew, interview, partner call; lunch. Partner call, dug at Kendy's nice timer patch; found a corner case or two causing grief still, and did some testing; dinner; back to work - pushed timer patch.
  • Rather pleased with Emma Watson's UN speech; with an encoruaging leading rebuke; I'd call myself a Feminist if it wasn't for the dismissive, man-hating, alternative fringe that she calls out. Still good to hear the obvious re-stated eloquently and helpfully: that women should be equal and we should be upset when they are not. Then again, I get tired of the horribly complicated issue of suicide being used to make political / gender points.

New Features in Picasso

I’ve always been a big fan of Picasso, the Android image loading library by the Square folks. It provides some powerful features with a rather simple API.

Recently, I started working on a set of new features for Picasso that will make it even more awesome: request handlers, request management, and request priorities. These features have all been merged to the main repo now. Let me give you a quick overview of what they enable you to do.

Request Handlers

Picasso supports a wide variety of image sources, from simple resources to content providers, network, and more. Sometimes though, you need to load images in unconventional ways that are not supported by default in Picasso.

Wouldn’t it be nice if you could easily integrate your custom image loading logic with Picasso? That’s what the new request handlers are about. All you need to do is subclass RequestHandler and implement a couple of methods. For example:

public class PonyRequestHandler extends RequestHandler {
    private static final String PONY_SCHEME = "pony";

    @Override public boolean canHandleRequest(Request data) {
        return PONY_SCHEME.equals(data.uri.getScheme());
    }

    @Override public Result load(Request data) {
         return new Result(somePonyBitmap, MEMORY);
    }
}

Then you register your request handler when instantiating Picasso:

Picasso picasso = new Picasso.Builder(context)
    .addRequestHandler(new PonyHandler())
    .build();

Voilà! Now Picasso can handle pony URIs:

picasso.load("pony://somePonyName")
       .into(someImageView)

This pull request also involved rewriting all built-in bitmap loaders on top of the new API. This means you can also override the built-in request handlers if you need to.

Request Management

Even though Picasso handles view recycling, it does so in an inefficient way. For instance, if you do a fling gesture on a ListView, Picasso will still keep triggering and canceling requests blindly because there was no way to make it pause/resume requests according to the user interaction. Not anymore!

The new request management APIs allow you to tag associated requests that should be managed together. You can then pause, resume, or cancel requests associated with specific tags. The first thing you have to do is tag your requests as follows:

Picasso.with(context)
       .load("http://example.com/image.jpg")
       .tag(someTag)
       .into(someImageView)

Then you can pause and resume requests with this tag based on, say, the scroll state of a ListView. For example, Picasso’s sample app now has the following scroll listener:

public class SampleScrollListener implements AbsListView.OnScrollListener {
    ...
    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
        Picasso picasso = Picasso.with(context);
        if (scrollState == SCROLL_STATE_IDLE ||
            scrollState == SCROLL_STATE_TOUCH_SCROLL) {
            picasso.resumeTag(someTag);
        } else {
            picasso.pauseTag(someTag);
        }
    }
    ...
}

These APIs give you a much finer control over your image requests. The scroll listener is just the canonical use case.

Request Priorities

It’s very common for images in your Android UI to have different priorities. For instance, you may want to give higher priority to the big hero image in your activity in relation to other secondary images in the same screen.

Up until now, there was no way to hint Picasso about the relative priorities between images. The new priority API allows you to tell Picasso about the intended order of your image requests. You can just do:

Picasso.with(context)
       .load("http://example.com/image.jpg")
       .priority(HIGH)
       .into(someImageView);

These priorities don’t guarantee a specific order, they just tilt the balance towards higher-priority requests.


That’s all for now. Big thanks to Jake Wharton and Dimitris Koutsogiorgas for the prompt code and API reviews!

You can try these new APIs now by fetching the latest Picasso code on Github. These features will probably be available in the 2.4 release. Enjoy!

Grids everywhere!

Hi dear readers,

it’s awesome to see people-really-excited (including our friends at Bloomberg) about CSS Grid Layout, specially after Rachel Andrew‘s talk in CSSConf. I really believe CSS Grid Layout will be a revolution for web designers as it will help them to build amazing responsive web sites without having to add hacks all around.

Me and my fellow Igalians keep working on adjusting the code to match the specification, polishing the code, adding new features and even drastically improving the performance of grid.

September 22, 2014

The LinkedIn Lawsuit Is a Step Forward But Doesn't Go Far Enough

Years ago, I wrote a blog post about how I don't use Google Plus, Google Hangouts, Facebook, Twitter, Skype, LinkedIn or other proprietary network services. I talked in that post about how I'm under constant and immense social pressure to use these services. (It's often worse than the peer pressure one experiences as a teenager.)

I discovered a few months ago, however, that one form of this peer pressure was actually a product of nefarious practices by one of the vendors — namely Linked In. Today, I learned a lawsuit is now proceeding against Linked In on behalf of the users whose contacts were spammed repeatedly by Linked In's clandestine use of people's address books.

For my part, I suppose I should be glad that I'm “well connected”, but that means I get multiple emails from Linked In almost every single day, and indeed, as the article (linked to above) states, each person's spam arrives three times over a period of weeks. I was initially furious at people whom I'd met for selling my contact information to Linked In (which of course, they did), but many of them indeed told me they were never informed by Linked In that such spam generation would occur once they'd complete the sale of all their contact data to Linked In.

This is just yet another example of proprietary software companies mistreating users. If we had a truly federated Linked-In-like service, we'd be able to configure our own settings in this regard. But, we don't have that. (I don't think anyone is even writing one.) This is precisely why it's important to boycott these proprietary solutions, so at the very least, we don't complacently forget that they're proprietary, or inadvertently mistreat our colleagues who don't use those services in the interim.

Finally, the lawsuit seems to focus solely on the harm caused to Linked In users who were embarrassed professionally. (I can say that indeed I was pretty angry at many of my contacts for a while when I thought they were choosing to spam me three times each, so that harm is surely real.) But the violation CAN-SPAM act by Linked In should also not be ignored and I hope someone will take action on that point, too.

2014-09-22: Monday

  • Mail chew, friendly partner call; worked through bugs at some considerable length with Andras; more mail chew; team call, lunch. Even more unbelievable admin, another team call. Dinner, put babes to bed, partner calls until late; reviewed Kendy's nice mainloop patch.

Mysterious Parcel

I received a package in the mail today!
Mysterious Package

Everything arrived all nicely packaged up in a hobby box and ready for assembly.
Opening the box

Lots of really interesting goodies in the box!
Out on the table

After a little while, I’ve got the first part together.First part assembled

The rest will have to wait for another day. In the meantime, have fun guessing what it is, and enjoy this picture of a cake I baked on the weekend:
Strawberry Sponge Cake

See you later!

Now Samsung @ London



I just moved back to Europe, this time to foggy London town, to join the Open Source Group at Samsung. Where I will be contributing upstream to GStreamer and WebKit/Blink during the day and ironically mocking the local hipsters at night.

After 4 years with Collabora it is sad to leave behind the talented and enjoyable people I've grown fond of there, but it's time to move on to the next chapter in my life. The Open Source Group is a perfect fit: contribute upstream, participate in innovative projects and be active in the Open Source community. I am very excited for this new job opportunity and to explore new levels of involvement in Open Source.

I am going to miss Montreal. It's very particular joie de vivre. Will miss the poutine, not the winter.

For all of those in London, I will be joining the next GNOME Beers event or let me know if you want to meet up for a coffee/pint.

GNOME 3.14 approaching

With 3.14 almost out of the door, it seems like a good opportunity to blow the cobwebs of this blog and highlight some shiny new features I was involved in during this cycle:

Gesture support in GTK+

It’s finally happening :), GTK+ 3.14 brings in infrastructure to handle gestures. Maybe the word “gesture” is automatically associated to “multitouch”, but actually this infrastructure is meant to deal with all kinds of pointer/touch input, and as such is used fairly intensively now within GTK+ itself, so even mouse users will be unknowingly using this.

These gesture objects are of course readily available for applications too. Individually, these are quite simple in essence, but can be easily stitched together to compound higher-level behavior. So far, eog and evince (and by extension gnome-documents) have bitten the bullet and now handle some of the gestures you’d expect on touchscreens there, the API documentation and HowDoI are available for anyone wanting to follow.

Gesture support in gnome-shell

Just to feed the cabal claiming that gnome-shell is designed for tablets, I also managed this cycle to add gesture infrastructure in mutter, so it is able to pre-process touch events before applications do, these events are then handled through ClutterGestureActions, or “rejected” and eventually handled by the application. This has been put to use in gnome-shell, making some actions readily available through multitouch.

Edge swipes

Showing the overview

Switching workspaces

Switching apps in a workspace

Note: Recorded with the help of this, bug #732367 is yet another 3.16 todo item…

Freebase support in libgdata

This one feature has certainly went underpublicited, and I found myself with little time to make use of it :(, but I nonetheless find that very interesting things can be done with this. Freebase is a community-maintained knowledge base (currently backed by Google), as seen on its homepage it is extremely wide in topics (some better covered than others), and has a very well defined ontology, think of it as a companion to Tracker on the web.

There are dedicated methods for the most usual ways to query data (search, lookup on topic…), but additionally Freebase offers a powerful MQL query method. MQL is very analogous to SPARQL, with the main difference that it’s based on JSON. All together allows for querying in very creative ways from very various data, a few examples being:

  • The mandatory “query for movie/album info” example, actually these topics are the best covered.
  • Fetching stock images for movies/cities/landmarks/directors/…, you name it.
  • Looking up monuments close to a geolocation.
  • Getting direct links to Wikipedia, in your language.

Looking forward for 3.15

It is almost time to celebrate, but I evidently won’t sit twiddling my thumbs :), a few items I’d like to tackle on the next cycle are:

  • During the 3.14 cycle I got briefly started on adding optional gesture integration to GtkStack and a new “tabs” widget, now it sounds like a good time to resume. I would also like to make gestures used integrally for event handling in GTK+ (we’re already just a few widgets away from that goal)
  • There’s a few gaps still left to solve on handling touchpad gestures, which I’d like to get closed ASAP, at least for touchpads handling >2 fingers on X11.
  • Improving gnome on Wayland. I merely got started this cycle adding DnD/clipboards support to GTK+ and bringing touchscreen behavior on mutter more or less on par to X11’s. There’s a few input details that need shuffling so they’re done in the same place on X11/wayland (pointer cursor visibility, device mapping…), and I hope the timing to be right to bring in a sort of tablet support (libinput and wayland protocol details have been shaping up despite my times on, most times off help, thanks Peter, Lyude, Jason et al!), I will be putting my hacking efforts wherever it’s necessary to make this happen.
  • WebKitGTK+ could be definitely made friendlier on touchscreens, additionally to the DOM touch event support it already does, it would be great to handle touch scroll/pinch/zoom as you can see in other pure GTK+ apps now.

3.14 almost there

First of all an apology to all the people who commented on the previous post: as you can see I do not blog often and when I logged into wordpress today I found a lot of comments waiting in the moderation queue for which I did not receive the notification mail…

This week GNOME 3.14 will get released, and once again I am astonished by the amount of work that went into this version: little by little every rough edge is getting polished and the increasingly good feedback we receive from users is a welcome change :-)

GNOME 3 made some bold design choices, some were huge leap forwards (and other more blasoned environments are playing catch-up) other were more controversial, but one of the fundamental differences with the past is that we try things and we are willing to evaluate their success and iterate the design even in radical ways, instead of having every little detail set in stone once it is merged. Even more exciting are the glimpses of the future: wayland support getting ready, gesture support merged in GTK, a better developer story materializing in the form of a proper SDK and new development tools like the GTK inspector, and much more.

For what it concerns myself, I have to admit that this time I did not manage to do that much code-wise, I guess my biggest achievement for this cycle, was to bring the ephemeral Lapo to GUADEC… and by bring I mean “physically drive to Strasbourg” :-)

Apart from that, I still managed to sneak in a couple of small “Sunday Afternoon” hacks, for instance Clocks now has a nifty gnome-shell search provider.

clocks-search

 

The rest of my time was mostly spent trying to keep up with reviewing patches and giving feedback to all the great contributors to gedit: I am lucky to be part of such a great project with long time contributors sticking around and new talented ones getting involved all the time.

Speaking of gedit,  after the major changes of 3.12, 3.14 has been a cycle focused on stabilization and polishing. Overall the revised user interface got mostly positve feedback.. I for one, as a heavy gedit user, adapted to the new UI without problems. 3.14 will have a few incremental changes, that among other things try to address some of the issues pointed out by Jim Hall’s usability study presented at GUADEC: “Open” will be a single button removing the dichotomy between the open dialog and recent files and providing quick search among recent files. “Save” now uses a text label since it turns out a lot of people did not grok the icon (and no, I am not going back to the floppy image!) and the view menu has been reorganized and now uses a popover. With regard to the “Open” button, we know things are not perfect yet, search among recent is great, but when the “cache misses”, going through a double step is painful… we already have a few ideas on how to improve that next cycle, but for now I can vividly recommend to try the “quickopen” plugin, one of the hidden gems of gedit, which already provides some of the things we would like to integrate in the next iteration.

gedit-open

Another aspect we (and by “we” I mean Jesse and Nacho) focused on, is to revive our cross-platform effort: not only both the Windows and OSX port have been updated, but they were also substantially improved. The even more important aspect is that a lot of this work was done at the GTK level and all application developers targeting these platforms will benefit from it. In this regard a large thank you goes to Руслан Ижбулатов (LRN on IRC) who has been tirelessly fixing issues on Windows.

These ports try to properly blend into their respective environment, and this was done with relatively little effort, a proof that some of the design decisions we took in the architectural changes we made last cycle were correct. We would very much welcome patches to do the same kind of integration work for Unity and other environments, though we’ll have to strike a good balance between integration with the environment and keeping a single design identity, providing a consistent user experience to users that use gedit across different platforms.

gedit-osx

Code also evolved under the hood: Sébastien continued in his great effort to push code from gedit to gtksourceview, and after the search API that he tackled during last year GSOC, this time he landed the rework of file loading and saving. This work is particularly important because it will be leveraged by Christian for Builder, a project I am extremely excited about, not only because we really need a tool to improve the the developer experience on GNOME, but also for its symbiotic relation with gedit, with code and design concept that are going to be shared.

 

 

 

 

Using EGL with GTK+

I recently needed to port some code from GTK+ OpenGL code from GLX to EGL and I couldn't find any examples of how to do this. So to seed the Internet here is what I found out.

This is the simplest example I could make to show how to do this. In real life you probably want to do a lot more error checking. This will only work with X11; for other systems you will need to use equivalent methods in gdk/gdkwayland.h etc. For anything modern you should probably use OpenGL ES instead of OpenGL - to do this you'll need to change the attributes to eglChooseConfig and use EGL_OPENGL_ES_API in eglBindAPI.

Compile with:
gcc -g -Wall egl.c -o egl `pkg-config --cflags --libs gtk+-3.0 gdk-x11-3.0` -lEGL -lGL

#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <EGL/egl.h>
#include <GL/gl.h>

static EGLDisplay *egl_display;
static EGLSurface *egl_surface;
static EGLContext *egl_context;

static void realize_cb (GtkWidget *widget)
{
EGLConfig egl_config;
EGLint n_config;
EGLint attributes[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE };

egl_display = eglGetDisplay ((EGLNativeDisplayType) gdk_x11_display_get_xdisplay (gtk_widget_get_display (widget)));
eglInitialize (egl_display, NULL, NULL);
eglChooseConfig (egl_display, attributes, &egl_config, 1, &n_config);
eglBindAPI (EGL_OPENGL_API);
egl_surface = eglCreateWindowSurface (egl_display, egl_config, gdk_x11_window_get_xid (gtk_widget_get_window (widget)), NULL);
egl_context = eglCreateContext (egl_display, egl_config, EGL_NO_CONTEXT, NULL);
}

static gboolean draw_cb (GtkWidget *widget)
{
eglMakeCurrent (egl_display, egl_surface, egl_surface, egl_context);

glViewport (0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget));

glClearColor (0, 0, 0, 1);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho (0, 100, 0, 100, 0, 1);

glBegin (GL_TRIANGLES);
glColor3f (1, 0, 0);
glVertex2f (50, 10);
glColor3f (0, 1, 0);
glVertex2f (90, 90);
glColor3f (0, 0, 1);
glVertex2f (10, 90);
glEnd ();

eglSwapBuffers (egl_display, egl_surface);

return TRUE;
}

int main (int argc, char **argv)
{
GtkWidget *w;

gtk_init (&argc, &argv);

w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_double_buffered (GTK_WIDGET (w), FALSE);
g_signal_connect (G_OBJECT (w), "realize", G_CALLBACK (realize_cb), NULL);
g_signal_connect (G_OBJECT (w), "draw", G_CALLBACK (draw_cb), NULL);

gtk_widget_show (w);

gtk_main ();

return 0;
}

On fêtera la sortie de GNOME 3.14 mardi soir à Lyon

In French, for a change :)

Mardi soir, le 23 septembre, quelques-uns d'entre nous se retrouveront vers 18h30 au Smoking Dog pour quelques boissons, et poursuivront avec un dîner indien prés du métro St-Jean.

N'hésitez pas à vous inscrire sur le Wiki, que vous soyez utilisateurs de GNOME, développeurs ou simplement des amis du logiciel libre.

À mardi!

Contacts 3.14

It’s been almost seven months since my last post and much have happened. Across the next posts I’ll be telling you some of what’s been and what will come. Yet, today’s post i about Contacts and the improvements we made on this cycle and you will see when GNOME 3.14 gets released.

The biggest greatest work on these past months was implementing inline contact creation. For a long time I had Allan’s mockups lying around, there were, also, some bugs concerning the “new contact dialog” and its behavior. So we set the goal to fix those and implement the feature this cycle. Doing this I realize the some internals cleaning in Contacts is in order, but, since feeling it is a big task I decided to delay it and hack our current ContactEditor widget to make it able to work on the new flow.

Down, at the end, are some screenshots.

We also worked a bit on others details. There’s a list here:

  • Updated all our dialogs to match latest Gtk+ design
  • Fixed the header-bar behavior and looks for selection and edit-mode
  • Fixed some bugs related to changing your default address bug. This included hacking into folks library, a work of which I am very proud.
  • Improved Adwaita dark variant support: Contacts maintained tweaked css code for colors definitions, we set out to use the defaults provided by the theme in order to work well with both variants.

I hope you can enjoy latest version on Contacts when it’s released. Go, find and bugs and improvements and let us know

A word on bugs

I’ve been trying to maintain Contacts’ bug list properly tagged and organized. In accomplishing that I’ve marked some as NEEDINFO, now, it’s been a while of this. I just wanted to let you know, I’ll be closing those bugs if they don’t get any updates before 3.14.1 is out on October 15.

September 21, 2014

Books

Woke up this morning and, as usual, sat down to read the Books section of The New York Times while drinking my coffee. This has become sort of a 'tradition' for me and because of it I have been able to learn about many interesting books, some of which I would not have found out on my own. I also 'blame' this activity to turning my nightstand into a mini-library on its own.

Currently I have the following books waiting for me:

Anyhow, while drinking my coffee this morning I realized just how much I enjoy reading and (what I like to call) catching up with all the books I either read when I was younger but took for granted or finally getting to those books that have been so patiently waiting for me to get to them. And now, whenever I'm not working or with my kids, you can bet your bottom dollar that you'll find me somewhere outside (when the mosquitos are not buzzing about the yard) or cozily nestled with a book (or two) somewhere quiet around the house.

Book Queue

But to the point of this story, today I realized that, if I could go back in time (which reminds me, I should probably add "The Time Machine" to my list) to the days when I was looking to buy a house, I would have done two things differently:

  1. wire the entire house so that every room would have a couple of ethernet ports;
  2. chosen a house with a large-ish room and add wall-to-wall bookcases, like you see in those movies where a well-off person takes their guests into their private libraries for tea and biscuits;

I realize that I can't change the past, and I also realize that perhaps it is a good thing that I took my book reading for granted during my high school and university years... I don't think I would have enjoyed reading "Dandelion Wine" or "Mrs. Dalloway" as much back then as I when I finally did. I guess reading books is very much like the process of making good wines... with age and experience, the reader, not the book, develops the maturity and ability to properly savor a good story.

Books

September 20, 2014

Fri 2014/Sep/19

  • I finally got off my ass and posted my presentation from GUADEC: GPG, SSH, and Identity for Beginners (PDF) (ODP). Enjoy!

  • Growstuff.org, the awesome gardening website that Alex Bailey started after GUADEC 2012, is running a fundraising campaign for the development of an API for open food data. If you are a free-culture minded gardener, or if you care about local food production, please support the campaign!

September 19, 2014

Announcing Shotwell 0.20 and Geary 0.8

We’ve released Geary 0.8 and Shotwell 0.20 today and I’m pretty excited about getting these out the door to our users.  Both releases include important fixes and some great new features.

Geary 0.8

While Geary 0.8 has a slew of new features and improvements, I would say the most visible for our users (compared to 0.6) are the following:

  • Robert Schroll’s redesign of the mail composer.  Not only does it look a lot sharper and more modern than before, it also operates inline in the main window—that is, you type your reply right below the email you’re responding to.  This means replying to a conversation is a more natural operation than opening a separate window or switching to a new view.  You can still pop the composer out into a separate window, just press the Detach button and you’re on your way.
  • Gustavo Rubio’s hard work to get signature support into Geary.  Now Geary will automatically insert a signature of your design into an email, whether new or replying to another.  This is one of the most-requested features for Geary, so it’s good to get this in.
  • I’ve put in some hard work on improving database speed and IMAP connection stability.  There’s still a couple of kinks here and there, but I feel like 0.8 is a big step forward in making Geary the kind of application you can leave on for days at a time without worrying about it slowing down, crashing, or losing its connection to the server.

In other words, if you’re a Geary user, you really should upgrade.

That said, here’s a more formal list of improvements:

  • Major redesign of email composer, now presented inline in main window
  • Composer will automatically add signature to emails
  • Saving drafts to server can be disabled
  • Improved interface, now using GtkHeaderBar and modern widgets
  • Database speed optimizations to reduce lags and improve read times
  • Improved connection handling and reestablishment
  • Show attachments lacking a Content-Disposition
  • Important bug fixes
  • Updated translations

The tarball for Geary 0.8 is available here.  Visit the Geary home page for more information.

Shotwell 0.20

Shotwell 0.20 has a more modest set of improvements, but it’s still growing and developing.  In particular, new photo sharing plugins were added and stability fixes have been included:

  • Support for Rajce.net and Gallery 3 photo services
  • Set background image for lock screen
  • Better detection of corrupt images during import
  • Important stability bug fixes
  • Updated translations

The tarball for Shotwell 0.20 is available here.  Visit the Shotwell home page for more information.

3.14 On Its Way

I recently put the finishing touches to the GNOME 3.14 release notes, which means that the next GNOME release is getting pretty close now. I never cease to be excited by new GNOME releases, nor to be amazed by our community’s ability to discernibly improve the GNOME 3 user experience release on release. I’m definitely at the point where I want to be running 3.14 all the time – it’s obviously a lot better than the previous version.

You’ll have to wait for the release notes to get all the details about what’s in the new release. Nevertheless, I thought I’d give a sneak peek at some of my personal favourite features.

Often with new releases we focus on the big new features – obvious bits of new UI that do cool stuff. One of the interesting things about this release, though, is that many of the most significant changes are also the most subtle. There’s a lot of polish in 3.14, and it makes a big different to the overall user experience.

New Animations

It’s quite a while since Jakub first posted his motion mockups for the applications view. Since then we’ve been steadily and progressively iterating towards those mockups. With 3.14 we’ve finally got there, and it was worth the wait. The most noticeable effect is the new “swarm” animation, but also a lot of other subtle touches, such as when you browse application folders, or when you launch applications. We’ve also reworked the animations for when windows are opened and closed.

Animations might seem like unimportant window dressing, but it’s surprising how significant they can be for the user experience. They are the glue which binds the different parts of the UX together. By smoothing the transition between views, windows and applications, they make the entire experience feel responsive, fluid and more pleasurable to use. (And they actually make everything feel a lot faster, too. But don’t tell anyone.)

Google Images in Photos

Photos 3.14

GNOME’s Photos app has been steadily maturing over the past couple of releases, and it is turning into the dependable core app that we want it to be. The big news for 3.14 is that Photos will now pick up your Google photos, so any images you’ve uploaded with Picasa, Android, or posted on Google+ will be immediately available there. This is obviously incredibly convenient for users of Google services, and I know I’m looking forward to being able to quickly browse my online photos from within GNOME 3.

Rewritten Adwaita

GTK+ 3 Widget Factory 3.14

Jakub and Lapo have been tireless during the 3.14 cycle, and have completely rewritten Adwaita (the GNOME 3 GTK+ theme). This was a huge undertaking – around 8,000 lines of CSS have been reduced to about 3,300 lines of SASS. This was primarily intended to improve the maintainability of the theme. As such, there hasn’t been a dramatic change in the theme. What has happened, though, is that every aspect of the theme has been gone over with a fine-toothed comb.

There are some more noticeable changes. Progress bars have got thinner. Spinners look different (so much better). Switches are a bit different. However, the more exciting thing for me is that pretty much every part of the theme has changed in a subtle way. Everything feels crisper, sharper, and a bit lighter. There’s also a lot of subtle animations now (thanks to CSS animation support in GTK+), adding to the feeling of polish.

Search More Things

System search has been one of the most successful parts of GNOME 3, in my opinion. The number of applications that are feeding results to system search has continued to increase with 3.14, with two really useful new additions. The first is Clocks, which will return search results for world cities. Search is all you need to do to find the time in a place throughout the world.

search-clocks

The second new search provider in 3.14 comes from the Calculator. As you might expect, this allows you to perform simple calculations straight from the search box. It’s pretty exciting to see system search in GNOME 3 become so versatile, and the great thing about it is that it’s always a single keystroke away.

search-calculator

Go Go GTK+ Inspector

GTK+ Inspector 3.14

I don’t usually write about developer-focused features when I preview GNOME releases, but I can’t talk about 3.14 without mentioning GTK+ Inspector. If you work with GNOME technologies – as I do – this tool is something of a revelation. It’s amazing how quickly it becomes a core part of how you work. I’m already wondering how I ever lived without it.

The inspector isn’t just useful. It is also a lot of fun, and makes it easy to experiment. if you’re not a developer, or you don’t regularly work on GTK+ apps, I’d still recommend trying it out. Just hit Ctrl+Shift+I and have a play around.

Waiting Time

This is just a small selection of the features that are coming in the new release. To learn about everything else that’s coming, you’ll have to wait for the release notes. 3.14 should be out next week.

Feeds