Monthly Archives: February 2020

DRM Plugin crashes after openSUSE Tumbleweed update

A few days ago openSUSE users started complaining about DRM Plugin crashes in Firefox after running a Tumbleweed update.

Netflix requires the DRM plugin in Firefox to be able to play encrypted videos. The plugin would crash due to a bug in Firefox 73. While this bug affected not just openSUSE users, but everyone using Firefox 73, it became apparent to TW users as v73 landed in the Tumbleweed repo.

Mozilla fixed the bug in the 73.0.1 release. I tweeted about that a little more than a week ago.

Firefox 73.0.01 is now available in the Tumbleweed repo. So, a quick update should fix your Netflix. 😉

Information for package MozillaFirefox:
---------------------------------------
Repository     : openSUSE-Tumbleweed-Oss                 
Name           : MozillaFirefox                          
Version        : 73.0.1-1.1                              
Arch           : x86_64                                  
Vendor         : openSUSE                                
Installed Size : 186.7 MiB                               
Installed      : Yes                                     
Status         : out-of-date (version 73.0-1.1 installed)
Source package : MozillaFirefox-73.0.1-1.1.src           
Summary        : Mozilla Firefox Web Browser             
Description    :                                         
    Mozilla Firefox is a standalone web browser, designed for standards
    compliance and performance.  Its functionality can be enhanced via a
    plethora of extensions.

DevCon 2020 is just about a month away

The annual Developers Conference of Mauritius is happening on 2 - 4 April. That leaves us like about a month of final preparations.

A bunch of DevCon regulars met today during Code & Coffee at Mugg & Bean, Bagatelle, to attend to tasks related to the website, discuss about sponsorship, review talk proposals etc. Things are progressing and we are definitely looking forward to a great conference.

Two nights ago the conference website went live at conference.mscc.mu.

At the moment it's basically a conference announcement with registration pending to be opened and it contains a list of confirmed sponsors. Some of the sponsors are our regular supporters and we are thankful for their continued trust. As for the first timers we are just as eager to welcome them to this yearly awesomeness.

Once the registration opens, I'll blog more about the conference and provide details on what to expect this year. 😉

Anatomy of a generic function in Rust

Consider the following function in Rust:

fn additems<T: Add<Output = T>>(i: T, j: T) -> T {
    i + j
}

It can handle different input types and thus it's called a generic function. The generic data type is represented by the capital letter T in this example. T is an arbitrary placeholder. It could be have been another letter, X, Y or V, but  when using T it can be easier to remeber that it refers to a "type".

I don't usually write code but I do enjoy reading and here the syntax of the function definition can be daunting at first. Let's have a look at a simpler version.

fn additems(i: i32, j: i32) -> i32 {
    i + j
}

We define a function called additems that accepts two arguments, each of 32-bit signed integer type and the function returns a value of the same type. If 64-bit integers or float values are passed on to the function it will throw a mismatched types error.

error[E0308]: mismatched types
  --> src/main.rs:13:24
   |
13 |     let sum = additems(5.0,6.0);
   |                        ^^^ expected `i32`, found floating-point number

error[E0308]: mismatched types
  --> src/main.rs:13:28
   |
13 |     let sum = additems(5.0,6.0);
   |                            ^^^ expected `i32`, found floating-point number

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0308`

By using generics we can make the function additems accept both float and integer values. Following an example from doc.rust-lang.org one would tend to try specifying the generic type T as <T> and start using it.

fn additems<T>(i: T, j: T) -> T { ... }

Alas, the compiler would complain about binary operation not possible on type B.

error[E0369]: binary operation `+` cannot be applied to type `T`
 --> src/main.rs:9:7
  |
9 |     i + j
  |     - ^ - T
  |     |
  |     T
  |
  = note: `T` might need a bound for `std::ops::Add`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0369`.
error: could not compile `namaste`.

The compiler is helpful enough to hint that we need to implement the std::ops::Add trait. Adding the following line use std::ops::Add; brings the Add trait into scope.

(More about these traits can be found in the Rust documentation about the overloadable operators module.)

The T type is then bound by the Add trait as <T: Add<Output = T>> and the complete block becomes:

use std::ops::Add;

fn main() {
   let sum = additems(5,6);
   println!("sum: {}", sum);
}

fn additems<T: Add<Output = T>>(i: T, j: T) -> T {
    i + j
}

The function additems can now accept two integers or two float values and do an addition operation on them.

oSLO Conference 🐧

oSLO is short for openSUSE + LibreOffice.

The two projects are celebrating their 15ᵗʰ and 10ᵗʰ anniversary respectively in 2020. To mark the occasion, openSUSE and LibreOffice projects are organizing a joint conference from 13ᵗʰ to 16ᵗʰ October 2020 in Nuremberg, Germany. The conference will take place at Z-bau (Frankenstraße 200). It is the same location where last year's openSUSE Conference was held.

openSUSE and LibreOffice conferences are meant to bring like minded people together to discuss about topics relative to the projects. People can learn, teach and share their passion about the projects.

Last September, openSUSE announced a logo design competition for this co-conference with LibreOffice. Early this month the winner of the competition was announced. Kukuh Syafaat from Indonesia won the hearts of the co-conference organizing team.

Logo design by Kukuh Syafaat for oSLO Conference, Nuremberg.

The conference is free to attend. Mark you calendar & join the fun!

Call for Papers

The organizing team is currently accepting proposals for sessions. The deadline for submission is 21 July 2020.

openSUSE Board election 2019-2020 result

The openSUSE Board election 2019-2020 reached an end on the night of 31 January 23h59 CET after running for about two weeks.

Four candidates ran in this election and the result is as follows:

Simon is re-elected and gets to serve for another term while Sarah replaces outgoing board member Gertjan Lettink.

281 out of 500 eligible members voted in this election.