Because of the incredible bargains during the Steam summer / winter sales, I have acquired 42 games over the last 6 years. My old openSUSE system was never able to play these games in a decent manner. Intel HD Graphics 4000 will only get you so far… I have looked into building a new AMD PC, which would allow me to run Linux / Steam games at high settings and 1080p. Recently I noticed a promotion for the HP Pavilion Power 580 desktop, equipped with a Ryzen 5 1400 processor and with a Radeon RX 580 graphics card. Heavily reduced in price. So I took the plunge and got myself a brand new desktop PC.

Design and hardware

The case of the HP Pavilion Power desktop looks pretty good. Its a very small case: 36.4 cm in height, 16.5 cm in width and 37.8 cm in depth. The front has some sharp triangular edges that make the desktop pleasant to look at.

One issue with the case is airflow. There are 2 side vents in this case. The fan in the back of the case blows in cool air. This is used by the processor cooler and hot air will immediately move out of the case. Which means the CPU is adequately cooled. The graphics card also gets cool air from below, but dispenses this air to an area where it cannot easily get out of the case. It needs to find its way out towards the top side vent located far to the left. It would have been better if there was an air vent directly in between the graphics card and the power supply.

Specifications and benchmarks

The specifications:

• AMD Ryzen 5 1400 CPU
• AMD Radeon RX 580 GPU
• 16 GB DDR4 RAM
• 128 GB M.2 SSD
• 1 TB 7200rpm HDD
• 1 x HDMI  port
• 3 x Display port
• 1 x Type C USB 3.0 port
• 3 x Type A USB 3.0 port
• 2 x Type A USB 2.0 port
• 1 x DVD re-writer
• 1 x SD card reader
• 2 x Audio-in jack
• 1 x Audio-out jack
• 1x Microphone jack
• 1 x LAN port
• 1 x 300W 80 plus bronze PSU

On the front side, there is a DVD re-writer, a SD-card reader, an USB 3.0 type-C port, an USB 3.0 type-A port and a headphone jack. So this case is very well equipped from the front to handle all your media. The backside of the case is less prepared for the job. It has 2 USB 3.0 ports and 2 USB 2.0 ports. It has the regular ports for audio in, audio out and microphone. The graphics card provides 1 HDMI port and 3 display ports. And it has an Ethernet port. I think that there are not enough USB ports on the backside. I have a wired keyboard and mouse that take up the two USB 2.0 ports. Which leaves me with 2 USB 3.0 ports for everything else. To combat this issue, I have connected a TP-Link UH700. Which provides me with 7 additional USB 3.0 ports.

The power supply is a 300W and its 80 plus bronze rated. It is sufficient, but I would be more comfortable with a 450W or a 550W unit. That would give the machine a bit of headroom.

For benchmarks, I always look at the benchmark scores on the websites: cpubenchmark.net and videocardbenchmark.net. In the table below I compare the HP Pavilion Power 580-146nd with my previous PC, the Zotac ZBOX Sphere OI520. The CPU of my new desktop is 2,5 times faster then the CPU in my previous PC. The GPU is a whopping 18 times faster. So that means that this new PC will provide me with a big increase in overall performance.

Installing openSUSE

I have wiped Windows from the system and installed openSUSE Leap 15. The installation went without a problem. However, there were some annoyances to resolve directly after installation.

The biggest one is sound. I hit an issue where the speakers ‘pop’ every time that a new video (YouTube) or new audio file (Amarok) started playing. This loud ‘pop’ was very annoying and not good for my speakers. I am not the first person to encounter this issue, as it was also posted on the openSUSE forms. The proposed solution by John Winchester resolved this issue for me. I now only hear this ‘pop’ during the startup of my PC.

Another issue is that my Bluetooth adapter is not recognized. I have installed the bluez-auto-enable-devices and bluez-firmware and bluez-tools. If I run the command “sudo rfkill list all”, it does find the Bluetooth adapter and indicates that it is not Soft blocked and not Hard blocked. But according to the KDE Plasma 5 desktop applet, no Bluetooth adapters have been found.

Furthermore the amdgpu-pro driver is not yet available for openSUSE Leap 15. The open source AMD driver is performing okay. But I did hit an issue where I cannot get the display to turn on again, a few hours after it was (automatically) switched off. This could very well be related to the graphics driver. I have now configured my PC to suspend after 3 hours. When I restart the PC from this suspended state, I don’t encounter this problem.

Gaming

This is the area where my new PC excels! I can run all games on very high settings and get frame rates higher than 60 Frames per Second. I would have expected some higher frame rates from the open source games that I tested. Some of these games are not very graphically intensive. But even with the RX 580, the frame rates are just good, but not great. The exception is Xonotic, a super fun FPS that not only looks great, but shows very high frame rates. And I must say that SuperTuxKart looks amazing with all settings at the highest level (6). I have listed the frame rates that I see on average below:

• OpenArena – 90 FPS
• Urbanterror – 125 FPS
• Xonotic – 90 to 200 FPS
• SuperTuxKart – 60 FPS
• SpeedDreams – 25 to 150 FPS

I can now play games on Steam that I couldn’t play before. I play these games on very high settings and 1080p. The frame rates are good, certainly considering the advanced graphics of these games. I have listed the frame rates that I see on average below:

• Rise of the Tomb Raider – 50 FPS
• BioShock Infinity – 90 FPS
• Half Life 2 – 90 to 120 FPS
• Road Redemption – 60 FPS
• Euro Truck Simulator 2 – 60 FPS

Multitasking

The HP Pavilion Power 580-146nd is a great multitasking machine. For fun, I tried opening LibreOffice Writer, LibreOffice Draw, Darktable, Amarok, Dolphin, Dragon Player, GIMP and Steam at the same time while playing music in Amarok. Programs opened instantly and the CPU cores / threads used very little of the available CPU power. In the future, I will use this desktop for testing various Linux distributions on Virtualbox, for developing photo’s with Darktable and for making movies with Kdenlive. So I will use a bit more of the available power. For ‘normal’ desktop usage this machine has plenty of power to spare.

Conclusion

The HP Pavilion Power 580-146nd packs a lot of power for a price that is hard to match when building your own PC. However, it might surprise you that I would not recommend this exact machine to others. The reason is that Nvidia cards are still better supported on openSUSE Leap 15. I feel that for most people, the HP Pavilion Power 580-037nd would be the better choice. This machine features an Intel i5-7400 CPU, a Nvidia GeForce GTX 1060 GPU and has 8 GB of RAM. The pricing is very comparable. And the outside of the machine is the same.

For me personally, this machine was absolutely the right choice. I am very interested in the AMD Ryzen CPU’s. I also like AMD’s strategy to develop an open source driver for its GPU’s (amdgpu) for the Linux kernel. I was looking for an AMD machine and this HP Pavilion Power 580-146nd fits the bill and then some.

Published on: 3 September 2018

I recently had a chance to learn Erlang. In the beginning, it was quite hard to find a good book or tutorial that gave a clear idea of the language and the best practices. Hoping this blog can help someone who wants to get started.

As I began, it started to strike me that modern languages like Go, Ruby, Javascript have parts which have some similarity with Erlang. The parts include concurrency aspects w.r.t. passing messages using channels in Golang, the way functions  return results of last executed expression in Ruby and first class functions in Golang/Javascript.

Erlang’s history revolves around telecom industry. It has been known for concurrency using light-weight processes, fault-tolerance, hot loading of code in production environments etc. The Open Telecom Platform (OTP) is another key aspect of Erlang which provides the framework for distributed computing and all other aspects mentioned above.

Some key points to keep in mind,

• Values are immutable
• Assignment operator (=) and functions work based on pattern matching
• No iterative statements like for, while, do..while.. etc. recursive functions serve the purpose
• Lists, Tuples (records – a hack using tuples) are very important data structures
• If, Case.. Of.. are the conditional blocks
• Guards are additional pattern matching clauses used with functions and Case.. Of..
• Every expression should return a value and last expression in a function automatically returns the result
• Functions are first class citizens
• Usage of punctuations ‘; , .’ etc. (one can relate this to indentation requirements in python)

Lets gets started with some code samples,

% Execute this from erlang shell. erl is the command
> N = 10.
10
%% The above statement compares N with 10 and binds N with 10 if its unbound. If its already bound with some other value, exception is thrown.

%% Tuple
> Point = {5, 6}
{5,6}

%% List
> L = [2, 5, 6, 7].
[2, 5, 6, 7]

%% Extracting Head and Tail from List is key for List processing/transformations
> [H|T] = [2, 5, 6, 7].
>H.
2
>T.
[5, 6, 7]

%% List comprehensions
> Even = [E || E <- L, E rem 2 =:= 0].
[2,6]

Lets take a look at the simple functions,

helloworld () -> hello_world.

The simple function will return hello_world, a constant string – atom. Lets have a look at a recursive function,

%% Factorial of N
factorial (N) when N =:= 0 -> 1;
factorial (N) -> N * factorial(N-1).

%% Tail recursion
tail_factorial (N) -> tail_factorial(N, 1).
tail_factorial (0, Acc) -> Acc;
tail_factorial (N, Acc) -> tail_factorial (N-1, Acc * N).

The factorial functions demonstrate how Erlang does pattern matching on function parameters, usage of  Guard (‘when’ clause), punctuations. We could have also written the statement as ‘factorial(0) -> 1;’ .

The second version tail_factorial demonstrates the optimized version using tail recursion to simulate the iterative method. In this method Erlang would remove the previous stack frames using Last Call Optimization (LCO). It is important to understand both techniques as recursion is used quite extensively.

Erlang has the following data types – atom, number, boolean (based on atom), strings and binary data. atom’s occupy more space and its better to using binary data type for strings of larger sizes.

Other builtin data structures are queues, ordsets, sets, gb_trees . Error, Throw, Exit, Try.. Of .. Catch statements provide the exception handling capabilities.

The most interesting part of the language is about spawning light weight processes and passing messages between them,

– module (dolphin-server).

%% API

– export ([dolphin_handler/0]).

dolphin_handler() ->

  receive

         do_a_flip ->

               io:format (“How about no ? ~n”);

          fish ->
io:format (“So long and thanks for the fish! ~n”);

          _ ->

               io:format (“we’re smarter than you humans ~n”);

     end,

     dolphin_handler().

%% From shell, compile dolphin-server module

>c(‘dolphin-server’).

%% Spawns a new process
> Dolphin = spawn (‘dolphin-server’, dolphin_handler, []).

<0.124.0> %% process id of the newly spawned process

%% Now start passing messages!!

> Dolphin ! fish.
So long and thanks for the fish!

>Dolphin ! “blah blah”

we’re smarter than you humans

Open Telecom Platform (OTP)

• gen_server – for implementing server side piece in client/server
• supervisor – for implementing a supervisor in a supervisor tree. It takes care of the details regarding restarting of processes, fault-tolerance etc.
• gen_event – for implementing event handling functionality
• gen_statem – for implementing state machines

https://learnyousomeerlang.com/contents is one of the best online books for understanding how to use Erlang,  best practices while building an application which is production ready.  Its good to take pauses and move with book as its quite exhaustive, but wonderfully written

The bug that caused two brown-paper-bag released in librsvg — because it was leaking all the SVG nodes — has been interesting.

Memory leaks in Rust? Isn't it supposed to prevent that?

Well, yeah, but the leaks were caused by the C side of things, and by unsafe code in Rust, which does not prevent leaks.

The first part of the bug was easy: C code started calling a function implemented in Rust, which returns a newly-acquired reference to an SVG node. The old code simply got a pointer to the node, without acquiring a reference. The new code was forgetting to rsvg_node_unref(). No biggie.

The second part of the bug was trickier to find. The C code was apparently calling all the functions to unref nodes as appropriate, and even calling the rsvg_tree_free() function in the end; this is the "free the whole SVG tree" function.

There are these types:

// We take a pointer to this and expose it as an opaque pointer to C
pub enum RsvgTree {}

// This is the real structure we care about
pub struct Tree {
    // This is the Rc that was getting leaked
    pub root: Rc<Node>,
    ...
}

Tree is the real struct that holds the root of the SVG tree and some other data. Each node is an Rc<Node>; the root node was getting leaked (... and all the children, recursively) because its reference count never went down from 1.

RsvgTree is just an empty type. The code does an unsafe cast of *const Tree as *const RsvgTree in order to expose a raw pointer to the C code.

The rsvg_tree_free() function, callable from C, looked like this:

#[no_mangle]
pub extern "C" fn rsvg_tree_free(tree: *mut RsvgTree) {
    if !tree.is_null() {
        let _ = unsafe { Box::from_raw(tree) };
                         // ^ this returns a Box<RsvgTree> which is an empty type!
    }
}

When we call Box::from_raw() on a *mut RsvgTree, it gives us back a Box<RsvgTree>... which is a box of a zero-sized type. So, the program frees zero memory when the box gets dropped.

The code was missing this cast:

    let tree = unsafe { &mut *(tree as *mut Tree) };
                                 // ^ this cast to the actual type inside the Box
    let _ = unsafe { Box::from_raw(tree) };

So, tree as *mut Tree gives us a value which will cause Box::from_raw() to return a Box<Tree>, which is what we intended. Dropping the box will drop the Tree, reduce the last reference count on the root node, and free all the nodes recursively.

Monitoring an Rc<T>'s reference count in gdb

So, how does one set a gdb watchpoint on the reference count?

First I set a breakpoint on a function which I knew would get passed the Rc<Node> I care about:

(gdb) b <rsvg_internals::structure::NodeSvg as rsvg_internals::node::NodeTrait>::set_atts
Breakpoint 3 at 0x7ffff71f3aaa: file rsvg_internals/src/structure.rs, line 131.

(gdb) c
Continuing.

Thread 1 "rsvg-convert" hit Breakpoint 3, <rsvg_internals::structure::NodeSvg as rsvg_internals::node::NodeTrait>::set_atts (self=0x646c60, node=0x64c890, pbag=0x64c820) at rsvg_internals/src/structure.rs:131

(gdb) p node
$5 = (alloc::rc::Rc<rsvg_internals::node::Node> *) 0x64c890

Okay, node is a reference to an Rc<Node>. What's inside?

(gdb) p *node
$6 = {ptr = {pointer = {__0 = 0x625800}}, phantom = {<No data fields>}}

Why, a pointer to the actual contents of the Rc. Look inside again:

(gdb) p *node.ptr.pointer.__0
$9 = {strong = {value = {value = 3}}, weak = {value = {value = 1}},  ... and lots of extra crap ...

Aha! There are the strong and weak reference counts. So, set a watchpoint on the strong reference count:

(gdb) set $ptr = &node.ptr.pointer.__0.strong.value.value
(gdb) watch *$ptr
Hardware watchpoint 4: *$ptr

Continue running the program until the reference count changes:

(gdb) continue
Thread 1 "rsvg-convert" hit Hardware watchpoint 4: *$ptr

Old value = 3
New value = 2

At this point I can print a stack trace and see if it makes sense, check that the refs/unrefs are matched, etc.

TL;DR: dig into the Rc<T> until you find the reference count, and watch it. It's wrapped in several layers of Rust-y types; NonNull pointers, an RcBox for the actual container of the refcount plus the object it's wrapping, and Cells for the refcount values. Just dig until you reach the refcount values and they are there.

So, how did I find the missing cast?

Using that gdb recipe, I watched the reference count of the toplevel SVG node change until the program exited. When the program terminated, the reference count was 1 — it should have dropped to 0 if there was no memory leak.

The last place where the toplevel node loses a reference is in rsvg_tree_free(). I ran the program again and checked if that function was being called; it was being called correctly. So I knew that the problem must lie in that function. After a little head-scratching, I found the missing cast. Other functions of the form rsvg_tree_whatever() had that cast, but rsvg_tree_free() was missing it.

I think Rust now has better facilities to tag structs that are exposed as raw pointers to extern code, to avoid this kind of perilous casting. We'll see.

In the meantime, apologies for the buggy releases!

I promised a closer look at GHashTable and ways to improve it; here's that look and another batch of benchmarks to boot.

This time around I've dropped most of the other tables from the plots, keeping only khash and adding results from my GLib branch and Rust's HashMap, the latter thanks to a pull request from Josh Stone. These tables have closely comparable performance and therefore provide a good reference. Besides, every table tested previously is either generally slower or more memory-hungry (or both), and including them would compress the interesting parts of the plot.

I'll try to be brief this time¹. For more background, check out my previous post.

Bad distribution

First and foremost, the distribution was terrible with densely populated integer keyspaces. That's taken care of with a small prime multiplier post-hash.

Peak memory waste

Previously, we'd resize by allocating new arrays and reinserting the entries, then freeing the old arrays. We now realloc() and rearrange the entries in place, lowering peak memory use by about a third. This can prevent going into swap or even crashing out on a memory-constrained system.

Overall memory waste

If you've got a sharp eye, you'll notice that overall memory consumption is lower now too. Whereas the old implementation always made space for 64-bit keys and values, the new one will allocate 32 bits when possible and switch to bigger entries on demand. In the above test, the keys are integers in the range [0 .. 2³²-1], reducing memory consumption by 20% overall. If values had been in [0 .. 2³²-1] too, the reduction would've amounted to 40%. A caveat though — negative integers (e.g. from GINT_TO_POINTER()) still require 64 bits due to two's complement/sign extension.

Load factor mistargeting

When GHashTable is subjected to churn/aging, it will accumulate tombstones, and eventually the sum of entries and tombstones will eclipse the maximum load, resulting in a cleanup. Since a cleanup is just a reinsertion in place, it's handled similarly to a resize, and we take the opportunity to pick a better size when this happens. Unfortunately, the grow threshold was set at .5 if the table got filled up the rest of the way by tombstones, resulting in post-grow load factors as low as .25. That's equal to the shrink threshold, so with a little (bad) luck it'd shrink back immediately afterwards.

I changed the threshold to .75, so the load factor intervals (not counting tombstones) now look like this:

• <.25 → shrink immediately → .5
• [.25 .. .75] → no change
• [.75 .. .9375] → grow on cleanup → [.375 .. .46875]
• >.9375 → grow immediately → .46875

This seems like a more reasonable stable range with less opportunity for fluctuation and waste, and there's still lots of headroom for tombstones, so cleanups aren't too frequent.

But it's slower now?

In some cases, yes — can't be helped. It's well worth it, though. And sometimes it's faster:

This particular run uses less memory than before, which is puzzling at first, since keys and values are both pointers. A look at the test's smaps reveals the cause:

01199000-08fb8000 rw-p 00000000 00:00 0 [heap]

The heap happened to be mapped in the lower 4GiB range, and GHashTable can now store 32-bit entries efficiently. That means pointers too.

I caught khash doing something interesting in this benchmark. Some time after the aging cycle has started (1), it initiates a tombstone cleanup. In this case it decides to grow the table simultaneously, starting at (2). This could be an example of the kind of load factor mistargeting I mentioned above — certainly it would have a very low load factor for the remainder of the test.

Robin Hood to the rescue?

Short answer: No. Long answer:

Rust uses Robin Hood probing, and the linear shifts required for insertion and deletion start to get expensive as the table fills up. It also came in last in a lookup-heavy load I ran. On the other hand it avoids tombstones, so there's no need for periodic cleanups, and deletions will make it progressively faster instead of slower. GHashTable's quadratic probing seems to hold a slight edge, albeit workload-dependent and, well, slight. In any case, I couldn't find a compelling reason to switch.

What about attack resistance?

The improved GHashTable is much more resistant to accidental misbehavior. However, it wouldn't be too hard to mount a deliberate attack resulting in critically poor performance². That's what makes Rust's HashMap so interesting; it gets its attack resistance from SipHash, and if these benchmarks are anything to go by, it still performs really well overall. It's only slightly slower and adds a reasonable 4 bytes of overhead per item relative to GHashTable, presumably because it's storing 64-bit SipHash hashes vs. GHashTable's 32-bit spit and glue.

I think we'd do well to adopt SipHash, but unfortunately GHashTable can't support keyed hash functions without either backwards-incompatible API changes or a hacky scheme where we detect applications using the stock g_str_hash() etc. hashers and silently replace them with calls to corresponding keyed functions. For new code we could have something like g_hash_table_new_keyed() accepting e.g. GKeyedHasher.

A better option might be to add a brand new implementation and call it say, GHashMap — but we'd be duplicating functionality, and existing applications would need source code changes to see any benefit.

¹ Hey, at least I tried.

² If you can demo this on my GLib branch, I'll send you a beer dogecoin nice postcard as thanks. Bonus points if you do it with g_str_hash().

I get a lot of questions about people asking me about what stable kernel should they be using for their product/device/laptop/server/etc. all the time. Especially given the now-extended length of time that some kernels are being supported by me and others, this isn’t always a very obvious thing to determine. So this post is an attempt to write down my opinions on the matter. Of course, you are free to use what ever kernel version you want, but here’s what I recommend.

Adapted from announcement to opensuse-factory mailing list:

Ever since the deployment of the new repository checker, or repo-checker as you may be familiar, for Factory last year there have been a variety of requests (like this one opensuse-packaging) to utilize the tool locally. With the large amount of recent work done to handle arbitrary repository setups, instead of being tied to the staging workflow, this is now possible. This means devel projects, home projects, and openSUSE:Maintenance can also make use of the tool.

The tool is provided as an rpm package and is included in Leap and Tumbleweed, but to make use of this recent work version 20180821.fa39e68 or later is needed. Currently, that is only available from openSUSE:Tools, but will be in Tumbleweed shortly. See the openSUSE-release-tools README for installation instructions. The desired package in this case is openSUSE-release-tools-repo-checker.

A project has been prepared with an intentionally uninstallable package for demonstration. The following command can be used to review a project and print installation issues detected.

$ osrt-repo-checker --debug --dry project_only home:jberry:repo-checker

[D] no main-repo defined for home:jberry:repo-checker
[D] found chain to openSUSE:Factory/snapshot via openSUSE_Tumbleweed
[I] checking home:jberry:repo-checker/openSUSE_Tumbleweed@9a77541[2]
[I] mirroring home:jberry:repo-checker/openSUSE_Tumbleweed/x86_64
[I] mirroring openSUSE:Factory/snapshot/x86_64
[I] install check: start (ignore:False, whitelist:0, parse:False, no_filter:False)
[I] install check: failed
9a77541
## openSUSE_Tumbleweed/x86_64

### [install check & file conflicts](/package/view_file/home:jberry:repo-checker/00Meta/repo_checker.openSUSE_Tumbleweed)

<pre>
can't install uninstallable-monster-17-5.1.x86_64:
  nothing provides uninstallable-monster-child needed by uninstallable-monster-17-5.1.x86_64
</pre>

Note that the tool automatically selected the openSUSE_Tumbleweed repository since it builds against openSUSE:Factory/snapshot. The tool will default to selecting the first repository chain that builds against the afore mentioned or openSUSE:Factory/standard, but can be configured to use any repository.

All OSRT tools can be configured either locally or remotely via an OBS attribute with the local config taking priority. The local config is placed in the osc config file (either ~/.oscrc or ~/.config/osc/oscrc depending on your setup). Add a new section for the project in question (ex. [home:jberry:repo-checker]) and place the configuration in that section. The remote config is placed in the OSRT:Config attribute on the OBS project in question. For example, the demonstration project has configured the architecture whitelist. The format is the same for both locations.

To indicate the desired repository for review use the main-repo option. For example, one could set it as follows in the demonstration project.

main-repo = openSUSE_Leap_42.3

The benefit of the remote config is that it will apply to anyone using the tools instead of just your local run.

As mentioned above the list of architectures reviewed can also be controlled. For example, limiting to x86_64 and i586 can be done as follows.

repo_checker-arch-whitelist = x86_64 i586

There are several options available (see the code), but the only other one likely of interest is the no filter option (repo_checker-no-filter). The no filter option forces all problems to be included in the report instead of only those from the top layer in the repository stack. If one wanted to resolve all the problems in openSUSE:Factory a project with such fixes could be created and reviewed with the no filter option set to True in order to see what problems remain.

Do note that a local cache of rpm headers will be created in ~/.cache/opensuse-repo-checker which will take just over 2G for openSUSE:Factory/snapshot for x86_64 alone. You can delete the cache whenever, but be aware the disk space will be used.

Enjoy!

When you’re planning a trip to Asia, Taipei probably isn’t be the first destination that comes to mind, as it’s often ignored in favor of more popular tourist spots like Tokyo or Hong Kong. But don’t ignore a trip to Taiwan’s big city — it’s an inexpensive, quirky metropolis with some of the best night markets in all of Asia. This is the second time i’ve visited Taipei for openSUSE Asia Summit.

FYI, The last openSUSE.Asia Summit was held in Tokyo, Japan.

Here we go. Me and the famous Mr. gecko!!

Thursday 9 Aug, Day -1 (Travel to Taiwan)

This time, 14 people came from Indonesia to join openSUSE Asia Summit 2018 in Taipei. We divided to 3 groups. One group flight from Juanda Surabaya (Darian, Aftian, Joko, Rania). One group at morning flight from CGK (Haris, Edwin, Estu). Last group with afternoon flight from CGK (Kukuh, Didiet, Rifki, Yan Arief) And 3 others people; Tonny, Iwan Tahari, Siska join a separate flight.

My group is the first team landing in Taiyuan Airport. At international arrival gate, Franklin Weng pick us up to hostel, but we decided to visited Frank office before going to Hostel. We meet Eric Sun and their team. Artistic team who create video for opening ODF Reader on Android. The video created using Blender Software.

22.00 we arrive at hostel. Many thanks to Frank for deliver us. :D. A few hours later, 2 more groups arrived at hostel. We are stay at same hostel. A comfort dormitory with share room. First Hostel, not far from Daan Park. Let call it a day and sleep all the night.

Friday 10 Aug, Day 0 (openSUSE Board and Community Meetup)

Today we plan join meetup at Taiwan SUSE Office after Friday Prayer. We visited Taiwan Grand Mosque, not far from Daan Park and our hostel. Before Friday Prayer, we take breakfast at Sakura Canteen (with Indonesian Food), next to Taiwan Grand Mosque. After praying, we going to SUSE office by walk. We came late to SUSE office, after lost direction. What a day!

Main discussion on SUSE Office

We meet openSUSE boards, SUSE Beijing and SUSE Taiwan, openSUSE Japan, openSUSE Taiwan; Ana Martinez and Simon, Sunny and team, Alcho and team, Takeyama and team, Sakana etc. You can watch meetup video from Sakana here.

Our discussion focus on some point:

• How to prepare for next summit. We start create guideline for better preparation
• How to engage more student to join GSOC for openSUSE Project. We plan to choose local coordinator each country to break gap between GSOC/Mentor Team from openSUSE and students from various county, especially Asia.
• openSUSE Asia Summit album. Takeyama as part of Japan openSUSE team hand over album to Sakana, as local committee for current summit.

Lets finish foods and take photos!! After that, we moved to near building for tonight’s party. COSCUP Welcome Party at Zhangmen Brewing — Breeze Songgao Store. Before party, Libre Office Taiwan invited us for dinner. Sounds like Taiwan Cuisine. Yummy..

19.00 we join the party. Nice place with Taiwan 101 as background. At this party I meet many friend from another community. Some people which I have meet at GUADEC 2015, some people I have meet at GNOME.Asia or FOSSAsia. Let’s call it a Big Reunion.

21.00 we back to hostel by MRT. Let’s rest for tomorrow but wait this is 1 day before Summit and I should check my laptop for prepare my presentation.

Saturday 11 Aug, Day 1 (Opening of openSUSE Asia Summit 2018)

This year, summit is special because joint event between openSUSE Asia Summit x GNOME Asia Summit x COSCUP 2018.

Venue at Taiwan Tech, International Building. Lets register first. I get nice booklet. There are the details of schedule, abstract from speaker, sponsor and etc. You can download apps too for detail of this event just search COSCUP at Google Play.

8:50 to 9:05 opening by Board members (Ana & Simon) at Main Hall. After that I join talk Open Source Social Innovation by Audrey Tang, a civic hacker and Taiwan’s Digital Minister in charge of Social Entrepreneurship.

Then I join Nuritzi Sanchez at 306 Room, The year of the GNOME. Mbak Nur, talk about what happening at GNOME this year; include their move to Gitlab, anonymous donation, etc. Nice talk and very impressive presentation.

Next lunch and move to 304 room. After lunch I join Aftian and Masayuki Igawa. Aftian talk about Nusantara Metode Input at openSUSE. What is Aksara Nusantara and how write using Aksara Nusantara at openSUSE. Nice history.

Masayuki Igawara talk How Building Tiny Private openSUSE Cloud using openstack and small server (1U). Interesting talk and very nice presentation.

After that, I join to 201 room. Get last presentation from  Max Lin. I start to prepare because my turn after Max Lin. I bring presentation about How Jogja Become City of GNU/Linux User Friendly. You can find my slide at this slideshares and read my story about this in Bahasa Indonesia Thank you for all friend who join my class, anyway.

After finish my duty, I join main hall again to watch Ralf Flaxa Talk, The Bright future of SUSE and openSUSE. until drop. First day will be closed by BOF Session.

We parting on three team. Ahmad Haris and Surabaya team join BoF with Libre Office Taiwan at Frank Office. Edwin, Kukuh join openSUSE BOF, here Kukuh start presentation to bid next openSUSE Asia Summit at Bali Island, Indonesia, and Shobha Tyagi bid too for India Team. After watch Kukuh presentation, I join to GNOME BOF.

at GNOME BOF we have some point:

• Max and Emily step down for Asia Committee after 10 years
• Review for GNOME Asia Summit.
• GSOC at GNOME

That’s all for 1st day of summit. Time to back and rest.

Sunday 12 Aug, Day 2 (openSUSE Asia Summit 2018)

I came late, spent morning for rest and catch up for my work. I join 201 room, Alcho with Introduction OBS, Kukuh with openSUSE Leap & Flatpak. After that watch Daniel Lin, Introduction to openSUSE Portus. Last, join 304 room, Yan Arief with, Having fun with KDE:create a Plasmoid.

We start moving to main hall again for the closing Summit.

After summit done. Kukuh, Edwin, Haris and me join COSCUP dinner with openSUSE Board, SUSE Team, GNOME Board, and local committee at Restaurant, using Bus. Try Tiawan Cuasine again. There’s so many dellicious food. Starting with sashimi;raw seafood, crab soup, fried crab, stinky tofu, fried rice, etc.

At 21.30 we came back to hostel.

Monday 13 Aug, Day 3 (One Day Trip)

Many Speaker join one day trip. We gather at Taipei Main Station. After that we visit National Palace Museum using bus from Taipei Main Station. See a lot of historical inheritance. After that, we are going to Taipei 101. Before going up, we get lunch at grand floor Taipei 101. Thanks for local committee to serve Halal Food. After lunch, see Taipei City from 88th floor Taipei 101 Observatory. We lucky can go out site at 92th floor because that day sky is very clear.

17.00 we move to Taipei City Mall, search for GUNDAM. Edwin, Haris and Tonny buy lot of them. Darian, Joko and Aftian leave first to Airport. They flight at tonight. 19.30 we move to Masalut Restaurant. Thanks Eric and Frank for the food. After dinner. Kukuh and team leave to Airport. They flight at tomorrow morning. So, Rania, Haris, Edwin, Iwan Tahari and me will be last team who leave Taipei.

Epilog

That all my story about my journey at Taipei. I’m happy can join this summit. I think, it is impossible for me get this experience without contribution to community. My contribution not about code, I help prepare local committee to held openSUSE Asia Summit as part of Asia Committee with Edwin, Sunny, Takeyama, Alcho and many other. Joko, Darian, Rania and Rifki; It will be their first time going abroad. What do you feel guys?

Many thank to openSUSE and Binar Academy for travel support. Thanks to Max Huang, Alcho and COSCUP Teams, also thanks to Franklin Weng and Eric Sun for warm welcome!

See you next year summit at Bali(maybe).

Estu

Other photo can be access at flicker groups:

• GNOME.Asia Summit 2018 https://www.flickr.com/groups/gnomeasia2018/
• openSUSE.Asia Summit 2018 https://www.flickr.com/groups/3094051@N21/
• COSCUP https://www.flickr.com/photos/coscup/albums (2018 still not uploaded yet)

PS: other story:

• Ahmad Haris: https://ahmadharis.wordpress.com/2018/08/19/gnome-asia-summit-2018-taipei-taiwan/
• Joko Susilo: https://medium.com/@jokosu_10/my-amazing-trip-to-coscup-x-gnome-asia-x-opensuse-asia-2018-e41a00c9b2d2
• Kukuh Syafaat: https://blogs.gnome.org/cho2/2018/08/18/coscup-2018-x-gnome-asia-summit-2018-x-opensuse-asia-summit-2018/
• Didiet Pambudiono: https://medium.com/@pambudiono.os/opensuse-asia-summit-2018-9ccfd045b68d
• Rifki Affandi https://rifki21blog.wordpress.com/2018/08/22/my-journey-opensuse-asia-summit/

This week will be my last at Unruly; I’ll be moving on just shy of nine years from when I joined a very different company at the start of an enthralling journey.

Unruly’s grown from around a dozen people when I joined to hundreds, with the tech team growing proportionally. Team growth driven by needs arising from commercial success with revenue growth, investment, being acquired, and continued success today.

A constant over the past few years has been change. We had continued success partly because we successfully adapted products to rapidly changing commercial contexts. Success in turn instigated change that required more adaptation.

It’s been a privilege to be part of a company that was successful, affording me with many opportunities and remaining interesting for nine years; I’d like to think I’ve played some small part in making it so.

It’s almost a meme in tech that one “should” move on to a new organisation every 2 years to be successful and learn. Those who stick in the same place for longer are sometimes even judged as lacking ambition or being content with not learning new things. “Do they have 9 years of experience or one year of experience 9 times?” people quip.

There are, however, benefits of staying at the same company for an extended period of time that don’t get talked about a great deal.

Witness Tech Lifecycle

A cliched reaction when reading code is “who [what idiot] wrote this?”. It’s easy to blame problems on the previous administration. However, to do so is to miss a learning opportunity. If we followed Norm Kerth’s prime directive:

“Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand.”

We could see code or systems that surprise us as an opportunity to understand what the context was that led people to build things in this way. Yes, perhaps they did not have the skill to see your “obviously better” solution. On the other hand maybe they had no idea that what they were building would be used for its current application. Maybe they had cost, or technological constraints that are now invisible to you.

Understanding the history of our software and systems can help us shape them into the future, avoid past mistakes, and improve our understanding of the domain at the current point in time.

It has been particularly interesting to see first hand how things play out with tech over an extended period of time, such as

• How early design decisions enable or limit longevity
• TDDed codebases supporting substantial change safely for many years
• Hot new hyped tech becoming tech nobody wants to touch
• Tech being used for drastically different purposes to what it was built for
• Code that is habitable and is “lived-in” out of necessity remaining easily maintainable for many years
• Highly reliable and valuable systems suffering from operational-underload. Having little need to change they fade from memory to the point that no-one knows how to make a change when it’s needed.
• Seeing the industry change rate outpace the rate at which software can be refactored.

Sticking around at the same place for a while makes it possible to observe all this happening. Even if you haven’t had the luxury of being a witness to the history, it’s an interesting exercise to dig through artifacts such as code, systems, documents, as well as speaking to those who were there to understand how things got to where they are today.

Witness Lifecycle of Practices

It’s been interesting to observe the cycle of teams trying new things to work more effectively. It often goes something like

1. Frustration with the ineffectiveness of an aspect of how the team is working
2. Experiment proposed
3. Adoption of new working practice
4. Cargo culted as “how we work”
5. The original intent is forgotten
6. The practice changes as people copy what they observe imperfectly
7. Context changes
8. The practice is no longer helpful; we keep doing it anyway out of habit
9. Repeat

It seems to be relatively easy to communicate traditions and rituals through time—the things that we do that can be observed by new colleagues.

It appears much harder to retain organisational memory of the intent behind practices. This can lead to practices being continued after they stop being useful, or being twisted into a semblance of the original practice that doesn’t achieve the same benefits.

This happens on trivial things e.g. a team found they were recording meetings just because other teams were doing so, even though no-one was listening to their recordings.

It also happens in more dangerous contexts—we observed our practice of continuous deployment drifting from a safe, tight feedback loop to a fire and forget strategy of hope. Newcomers had observed regular, confident deploys, but missed the checking and responding part of the feedback loops.

Even well documented XP practices are not immune to this: the practice of continuous integration becoming synonymous with tooling and then used to support isolation rather than integration. TDD becoming synonymous with writing tests first rather than a feedback loop—creating resistance to refactoring rather than enabling it.

Various things help teams pick up on these sort of problems and adapt, but it takes longer to recognise there’s a problem when intent has been forgotten.

Our teams have regular retrospectives with facilitators from other teams. We’ve encouraged blogging & speaking about the way we work, both internally and externally. We even have a team of coaches who work to help teams continuously improve.

None of these are sufficient. I think where we’ve been most effective at retaining both practices and understanding of intent is where there’s a clear narrative that can be retold to new people in the team. e.g. tales of wins originating from Gold Cards (20% time), help people to understand why they’re valuable.

Sticking in the same place for a while gives the luxury of remembering the original intent behind working practices. Even if you’re new to a team it’s worth questioning things the team is doing, rather than assuming there’s a good reason; try to understand the intent and see if it’s still achieving that today. Fresh eyes are valuable too.

Observe Teams Grow

Seeing the same organisation at different stages of growth is quite interesting. Observing practices that worked at one scale ceasing to be effective.

It’s easy to look at things that work at other organisations and assume that they’ll work where you are as well. However, it’s enlightening to see things that used to work in your own organisation cease to work because the context has changed.

Take deployment strategies: when all your users are within earshot you can maybe just shout that there’s going to be an outage and see if anyone objects. At a larger scale, zero-downtime deployments become important. When risk is higher, things like canary deploys and blue-green deployments become necessary (if you want to continue to deliver continuously).

Take communication: if the team is small and co-located perhaps everyone can know what’s going on through osmosis. As the team grows, more deliberate communication is needed to keep people informed. As scale increases, more and more effort is needed to distil meaning from the noise of information.

Safely Explore Different Roles

Sticking in one place for a while affords one the luxury of not having to learn a new tech stack, domain, and culture. There’s of course plenty to learn just to keep up with the pace of change within the same tech stack and domain, but enough remains constant to create space for other learning.

For me it created space to learn leadership skills, change management skills, people management skills, coaching skills, facilitation skills and more.

In a supportive organisation it may even be possible to try out different sorts of roles without risking being out of a job if it doesn’t work out. Charity Majors’ post on the engineer manager pendulum really resonates with me. I’ve enjoyed the the opportunity to switch between very different roles within product development over the past few years. Others have even switched between BizDev, Adops, Product, Data and Development roles.

The last few years

I’ve been privileged to work for a supportive company that has provided me with opportunities without hopping around. I’ve had the honour of working with many brilliant people from whom I’ve learnt a great deal.

In the last nine years I’ve made many mistakes, and lived to correct them. I’ve helped build products that failed, and helped turn them into a success. I’ve hurt people, and been forgiven. I’ve created conflicts, and resolved them. I’ve seen code become legacy, and salvaged it. I’ve caused outages, and recovered from them.

I’m not suggesting that everyone should stick at the same place for a long time, just that it can be fulfilling if you find yourself in a place as great as Unruly.

The post The unsung upsides of staying put appeared first on Benji's Blog.

GNOME Asia Summit 2018 this time happen in Taipei – Taiwan, at National Taiwan University of Science and Technology, August 11 – 12, 2018. This summit is co-host between openSUSE Asia Summit and COSCUP, so the summit title is COSCUP 2018 x openSUSE Asia Summit 2018 x GNOME Asia Summit 2018.

I arrived at Taipei at Thursday – August 9. Franklin Weng from LibreOffice Taiwan pickup me at airport and go stright to A+A Workshop. A+A Workshop was place that FOSS Community from Taiwan used for meetup every Thursday. Franklin introduce me to others. Then go to First Hostel to meet other friends from Indonesia who also attend this conference. Most of them from openSUSE Indonesia.

#0 day

On Friday, me and others have free time. We go to Taipei Grand Mosque to Jum’ah (Friday) Praying, then I meet my High School Friends who live in Taipei. Then I go to Microfocus office to meet other Indonesian and openSUSE Community. At night, have dinner with LibreOffice Community around Asia, LibreOffice Taiwan (Franklin Weng) paid for our food.

Then we go to welcome party for speaker and staff. My role for this event was part of international staff, so I have invitation for this with others. It’s good time to see each others and good night few. Few openSUSE and SUSE member discuss with me about potential held openSUSE Asia Summit and GNOME Asia Summit together next year.

#1 day

This summit was very crowd comparing to COSCUP 2016 (I became speaker at that time). On first day attended by 1364 participant and on second day attended by 784 participant. It has 15 parallel classes. Few of them are in English, especially from openSUSE and GNOME.

In this summit, I help to manage coordinating for web content, design, and also material design such as logo. Many friends from Taiwan and Indonesia contribute in this. I’m not become speaker this time, but I bring few students and they become speaker.

On first day, I’m joining Benjamin Berg class, he’s talking about “Supporting Miracast on the GNOME Desktop” which is very interesting for me comparing to others. Then “Desktop applications: life inside a sandbox” by David King then The Year of the GNOME by Nuritzi Sanchez. I spent few hours for discussion with other participant. Sharing mine and their activity about contributing to FOSS. And also I try to find praying room, and found it next conference building. So comfortable. The organizer also give me food that compatible with Halal Food, and I see Sobha and her student got vegetarian food. It’s prepared well.

At evening, we have official two official BoF (openSUSE and GNOME) and one unofficial BoF (LibreOffice). I was realy confuse which one that I must join. But I made decission, because I bring 3 students that contribute in LibreOffice this year, so I will help them to join LibreOffice BoF. Before we go, I told Kukuh to join openSUSE BoF (because he’s President of openSUSE Indonesia Community, but also GNOME Foundation Member), Estu and Siska join GNOME BoF (both of them also GNOME Foundation Member). But suddenly, Siska joining LibreOffice BoF.

In this BoF, we share experience between each person about contributing LibreOffice with different ways each of us. And also we have food here. This is my first time eat Sushi.

#2 day

I was late going to venue, I’m not joining for keynote speaker session and directly going to class at break time. Starting my day with Bin Li’s class talking about Flatpak vs Snap. The class in Chinese but slide in English, still understanable for me. Then go to Iwan’s class which talking about Using Inkscape do Design Shoes.

After lunch I joining two Kukuh’s class, first about GNOME Recipes & Local Wisdom then openSUSE Leap & Flatpak.

In evening I invited by COSCUP to join dinner together other Indonesian going to Ximending to buy some souvenir. I was the same table with Max Huang, Ines, Sunny, Edwin Zakaria, Kukuh, Estu, Fuminobu Takeyama, Naruhiko Ogasawara, and Syuta Hashimoto. The food is good and many COSCUP staff here so we have lot of chat each others. They also prepare Muslim compatible food and also vegetarian food. Sunny help us to tell wich one that contain pork.

#3 Day

This is last day of the event, I joining one day tour for speaker. Going to National Palace Meuseum and Taipei 101. I’m not excited because I’ve been here. NPM for second time and Taipei 101 for third time. But having together with other are good for me.

At Evening, Franklin and Eric invite all Indonesian to have dinner (again). IMHO, this is the best food that I have when visiting Taiwan this time.

Notes

1. I’m GNOME Foundation Member and The Document Foundation Member, also from openSUSE Indonesia Community. Because of this, I have many chance to have chat with others.
2. There’s no GNOME Exhibition Booth this time
3. I help 3 students going to this conference, they never going abroad. I hope after this they can share their experience to others to increase contributor in Indonesia
4. I have meeting on second day with Max, Emily, Sammy and Haggen. Max stepdown from GNOME Asia Committee. Both Max and Emily handle lead GNOME Asia for decade. Now it’s me and Sammy.

Thanks to Max Huang and COSCUP Teams, also thanks to Franklin Weng and Eric Sun!

Si usáis vuestro teléfono Android para crear y manejar waypoints casi seguro conocéis Oruxmaps, probablemente la mejor app para geolocalización y mapas (por aquí ya ha salido varias veces).
Oruxmaps genera una pequeña base de datos (formato SQLITE) donde archiva todos los registros generados. Normalmente esta base de datos se encuentra en /storage/sdcard/oruxmaps/tracklogs/oruxmaps.db.
Si necesitáis extraer waypoints de la BD para (por ejemplo) consultarlos en GoogleEarth, podéis generar un KML así:
echo "Name,Latitude,Longitude,Description" > actual.csv && sqlite3 oruxmapstracks.db "SELECT poiname || ',' || poilat || ',' || poilon || ',' || '\"' || poidescr || '\"' from pois where poifolder='actual'" >> actual.csv && gpsbabel -i unicsv -f actual.csv -o kml -F actual.kml
Esta línea genera un archivo CSV con los waypoints que tengo en la carpeta “actual” de Oruxmaps y a continuación lo convierte a KML con gpsbabel

En esta imagen podéis ver todas las tablas y campos de la BD de Oruxmaps.