Initially, I wanted to blog about my travels. In the end, I refactored old code on my computer to publish eventually my first Ruby gem in the official repo at RubyGems. Welcome now jekyll-onebox on Github and RubyGems! :tada: :clap:

So if you use Jekyll for blogging, you can install this plugin and add HTML previews for links to popular websites very easily.

{% onebox https://github.com/rriemann/jekyll-onebox/blob/master/README.md %}

The previews are rendered using the gem onebox that powers link previews for Discourse forums.

Have fun with it and let me know if you encounter problems!

The Original Story Behind This Conference

Yes, Sokibi and Rania already write the story about how we starting the conference. It’s true but not complete one. The original one was before I have dinner with Sokibi and Rania. I have lunch with Kukuh and Moko in Soto Betawi Restourant near my house.

We’re thinking that in 2017 there’s no FOSS Conference in Indonesia. So we decide to organize conference about LibreOffice but small one (we can call it mini conference). But time flows, and we kick out “mini” and become normal conference.

The Document Foundation

Since Franklin Weng becoming board in TDF, he often pursuade me to joining TDF Membership. Well, I’m thinking that I less contribution on LibreOffice and little experience in that (except for personal/daily use). I have lot of experience in OpenOffice, an era before LibreOffice.

So, with organizing this conference, it’s my starting point to contribute to LibreOffice and of course I apply the membership and TDF will process my submission this month.

Start Organizing Conference

We start work in December 2017, preparing the proposal and choose which city and university for the venue. We asking two universities and good will comes from PENS (Politeknik Electronika Negeri Surabaya). We start working on Januari 4th, and prepare everything daily.

We have 9 members of organizer in first place, but then one member just gone away not active, so I kicked him out. Our member was come from different cities, luckly it’s still in one timezone. So we just have 8 powerfull members. In last week near the event, there’s about 25 students from university that joining us as local community organizer.

My main role is as coordinator and fundraiser. It’s easy but not easy. But I have good team members. In the event it’s self I was complicated busy, make sure everything work and run perfectly. But me and others are happy.

Honorable mention Rania, Moko, Kukuh, Joko, Darian, Ummul, and Tamara. The last one can’t attend the conference.

Day #-1

I arrived at Surabaya on Thursday, one day before workshop. I need to come early to make coordination with local organizer and pickup Franklin and Eric. Both of them are my old friends.

Mr. Ardi (lecturer from PENS who also local organizer) told me in telegram chat, that in Day#1, I need to have speech to open the conference with some professor. I bought batik shirt for this special moment.

Day #0

This is workshop day. I visited the venue and meet Mr. Ardi. I see the workshop for couple minutes and then at lunch time, I have meeting with Franklin, Eric, Andika, Noor, Darian, Estu and Lecturer/Professor from PENS.

In that meeting we have introduce our self and have small discussion. The Director of PENS also open the conference, because on Day#1 he can’t attending it.

I stay in Rumah Kertajaya Hostel, same with Franklin, Eric and Italo. I choose this because Italo already book this place and I need to have better communication and coordination with them.

Day #1

This is my special day. It’s rare to see me use formal shirt, especially batik shirt. I have opening speech as coordinator of organizer.

I spent this day to meet other speaker, have small discussion and make sure everything works smoothly. Also must sign many documents related to sponsorship from government.

I’m not attending any class this day. Only for Keynote.

Day #2

This day, I use spiderman t-shirt. Hahaha. I wanna make this day little bit more relax. I attend one class, about LibreOffice for Writing Scientific Work in Arabic by Rizki Fauzi. Yes I able to read and type in Arabic.

I also becoming moderator for Q&A with TDF before closing ceremony. Becoming moderator is not easy (it’s true) because Italo are person who love to tell his experience and good story teller. I can’t stop him many times.

The closing ceremony was cheerful, you can see it on LibreOffice Conference Indonesia 2018 group.

Day #3

Day #3 was city tour day. We have mini bus contain foreigner speaker, few local speaker and local organizer. We going to neighboor city of Surabaya, Mojokerto, which still have ancient Majapahit museum and temple.

We’re also going to Sampoerna Museum and Mirota Batik Store. Italo need to buy many of them.

Day #4

Me, Italo, Eric and Franklin have discussion session with PENS. It talk about curriculum and implementation in IT world.

In afternoon, Italo and Franklin become Guest Lecturer.

In evening, I also become Guest Lecturer. My class talking about Ridon.id.

Day #5

This day Franklin, Eric and Italo departed from Surabaya in the morning. In evening I also departed using night train.

Dinner

We actually have dinner sponsored by LibreOfficeID since Day #-1. Delicious dinner and have good stories from each other. Take a look at flickr if you want to see the picture.

Summary

Here my personal summaries about this conference:

• This conference is biggest FOSS conference in 2017 and 2018 in Indonesia
• Many people still doesn’t know about LibreOffice
• It’s quite difficult to get sponsorship from IT company
• Organizing conference outside JABODETABEK is different. Also the participant, many issues such as ticket price, transportation and hotel
• Collaboration with students are difficult in the beginning, but at the end, there’s few students are good and joining community
• Many student in PENS able to speak English. It’s opposite from last two conference (GNOME Asia and openSUSE Asia) in Indonesia
• Meet other/community members are good for your helth
• There’s a lot of chance to contribution and travel arround the world

I am happy to announce the release of the stable Kraft version 0.80 (Changelog).

Kraft is desktop software to manage documents like quotes and invoices in the small business. It focuses on ease of use through an intuitive GUI, a well choosen feature set and ensures privacy by keeping data local.

After more than a dozen years of life time, Kraft is now reaching a new level: It is now completely ported to Qt5 / KDE Frameworks 5 and with that, it is compatible with all modern Linux distributions again.

KDE Frameworks 5 and Qt5 are the best base for modern desktop software and Kraft integrates seamlessly into all Linux desktops. Kraft makes use of the great KDE PIM infrastructure with KAddressbook and Akonadi.

In addition to the port that lasted unexpectedly over 12 months, Kraft v. 0.80 got a whole bunch of improvements, just to name some examples:

More Flexible Addressbook Integration

As Akonadi is optional now, Kraft can be built without it. Even if it was built with, but Akonadi for whatever reason is not working properly, Kraft still runs smoothly. In that case it only lacks the convenience of address book integration.

The Address book access was also nicely abstracted so that other Addressbook backends can be implemented more easily.

GUI Improvements

Even though the functionality and GUI of Kraft was not changed dramatically compared to the last stable KDE 4 version, there were a few interesting changes in the user interface.

• A new, bigger side bar simplifies navigation.
• In the timeline view, a click on years and month in the treeview show summaries of the selected time span, ie. the number of documents with financial summaries per month or year.
• A filter allows to limit the view on the current week or month.

Reduction of dependencies

Kraft makes broad use of the core Qt5 libraries. The required KDE dependencies were reduced to a bare minimum. Akonadi libraries, which enable KDE PIM integration are now optional. The former dependency on heavyweight web browser components were completely removed and replaced by the far more simple richtext component of Qt.

These changes make it not only easier and more transparent to build Kraft but allow make a port to other platforms like MacOSX more easy in the future.

Under the Hood

A countless number of bugfixes and small improvements went in. Also updates to the newer C++ concepts where applicable make the rather mature code base more modern and better maintainable.

The Reportlab based PDF document creation script was updated and merged with a later version for example.

Deployment

Installing Kraft is still a bit complicated for unexperienced users, and distributions sometimes haven’t made a good job in the past to provide the latest version of Kraft.

To make it easier to test, there is an AppImage of Kraft 0.80 available that should be runable on most modern distributions. Just download a single file that can be started right away after having added the executable permissions.

Linux packages are already built for openSUSE (various versions) or Gentoo.

Kraft’s website will contain a lot more information.

Heute wurde Kraft Version 0.80 herausgegeben.

Nach mehr als zwölf Jahren Lebenszeit beginnt für Kraft heute eine neue Ära: Kraft ist jetzt auf Qt5/KDE Frameworks 5 portiert und damit wieder problemlos auf modernen Linux Distributionen lauffähig.

KDE Frameworks 5 und Qt5 sind die beste Basis für einen modernen Desktop, aber Kraft integriert gut mit allen verfügbaren Linux Desktop Systemen. Mit KDE kann Kraft das Akonadi-basierte Adressbuch zur Adressverwaltung nutzen.

Zusätzlich zur Portierung, der mehr als die letzten 12 Monate in Anspruch nahm, beinhaltet Kraft V. 0.80 eine große Menge an Verbesserungen, zum Beispiel:

Weniger Abhänigkeiten

Kraft verwendet vor allem die Qt5 Bibliotheken. Die verwendeten KDE Frameworks Abhängigkeiten wurden bewusst auf das nötige Minimum reduziert. Die Akonadi-Bibliotheken, die die KDE-Adressbuch-Integration ermöglichen, sind jetzt optional. Die vorherige Verwendung von einer schweren Webbrowser-Komponente wurde komplett entfernt und von einer viel simpleren, in Qt integrierten Richtext-Komponente ersetzt.

Alle diese Änderungen machen es nicht nur einfacher, Kraft zu übersetzen, sondern vereinfachen einen möglichen Port auf andere Platformen wie MacOSX oder Windows.

Adressbuch-Integration

Da Akonadi nun optional ist, kann Kraft ohne es übersetzt werden. Selbst wenn es mit gebaut wurde, aber Akonadi aus irgendwelchen Gründen nicht funktioniert, läuft Kraft ohne Probleme weiter. Es fehlt dann lediglich der Komfort der Adressbuch-Integration und Adressen müssen manuell eingetragen werden.

Die Empfehlung ist weiterhin, die gute Integration mit dem Akonadi-basierten Adressbuch zu verwenden.

Benutzeroberfläche verbessert

Auch wenn die Funktionalität von Kraft in diesem Release im Vergleich zum letzten KDE4-basierten Release nicht wesentlich verbessert wurde, sind doch einige interessante Veränderungen passiert.

• Eine neue, größere und vereinfachte Seitenleiste erleichtern die Bedienung
• Im Zeitverlauf kann jetzt auf ein Jahr oder einen Monat geklickt werden und es wird eine Übersicht der versendeten Dokumente in dem Zeitraum angezeigt.
• Ein Filter erlaubt die Reduzierung der angezeigten Dokumente auf die aktuelle Woche oder den letzten Monat.

Unter der Haube

Zusätzlich wurden eine große Menge weiterer Fehlerbehebungen und Verbesserungen eingebracht. Ausserdem erleichtert der Umstieg auf modernere C++ Standards die Weiterentwicklung und Pflege der Software.

Installation

Kraft zu installieren ist nicht einfach, und Linux-Distributionen haben in der Vergangenheit nicht immer einen guten Job gemacht, die aktuelle Version von Kraft zu liefern.

Um es einfacher zu machen, Kraft auszuprobieren, wird ab jetzt ein sog. AppImage von Kraft angeboten, das auf den meisten modernen Linuxen lauffähig sein sollte. Dazu muss nur ein einziges File heruntergeladen werden.

Прочитав заметку Кая Уве о глобальном меню в Plasma 5.13, я уже приготовился было ждать июня, когда эта версия официально выйдет, однако меня ждала хорошая новость! В новой версии openSUSE Leap 15.0, которая тоже ещё не вышла, но уже довольно давно доступна как бета-версия, уже давно всё сделано и работает! Напомню, что речь идёт о поддержке глобального меню не только для Qt-приложений, но и для GTK-программ. Это значит, что в Plasma теперь можно добиться гораздо лучшей интеграции чужеродных приложений (не основанных на Qt5) и наслаждаться отличным и единообразным видом программ, использующтх разные графические библиотеки.

Картинки покажут всё лучше слов, поэтому смотрим:

Для начала — список установленных пакетов, без которых ничего получится

Затем нужно просто добавить на рабочий стол верхнюю панель с меню приложений. В Plasma 5.12 это стало проще, так как больше не нужно идти в настройки стиля и выбирать там расположение меню. Теперь вы просто добавляете стандартную панель с меню и всё происходит автоматически. Так, к примеру выглядит у меня Gimp:

А так — Inkscape:

C Libreoffice нужно немного повозиться. Во-первых, потребуется установить VCL-плагины для интеграции пакета c GTK2 и GTK3 (увы, VCL-плагин для KF5 разрабатывается, но пока не готов). В openSUSE это пакеты libreoffice-gtk2 и libreoffice-gtk3. Затем нужно запустить любой из нужных вам компонентов, предварительно объявив переменную SAL_USE_VCLPLUGIN, например так:

SAL_USE_VCLPLUGIN=gtk oowriter

Результат:

Это просто кра-со-та! Теперь в моём любимом KDE глобальное меню почти так же универсально как и в macOS, и уже явно не хуже чем vala-appmenu, которое работает в XFCE и Mate.

UPD.

Среди Linux-блогеров, которых я читаю, есть некий Alex285, являющийся большим фанатом Gnome. Он ведёт интересный блог World of Gnome (WOGUE), откуда удобно узнавать о самых свежих новостях, связанных с Gnome. Я слежу за этой темой для того, чтобы знать, что из себя представляет современный Gnome Shell и мир GTK3-приложений. Вдруг, в какой-нибудь параллельной вселенной или мире розовых пони так случится, что Gnome станет быстрее, удобнее и надёжнее чем KDE Plasma, и тогда мне придётся перейти в стан гномолюбов — хотя бы для того, чтобы оставаться честным с самим собой. К счастью, в реальном мире  всё происходит ровно наоборот: последние версии Gnome (3.22-3.28) работают в моём VirtualBox заметно медленнее чем Plasma, а про убогий набор функций Gnome можно говорить бесконечно.

Так вот, этот самый блогер внезапно очень нервно и агрессивно отреагировал на новость про глобальное меню в KDE. Дескать, это всё не нужно и вообще, вместо меню разработчикам нужно работать над стандартным API приложений, чтобы их функции были доступны из HUD (это такая вываливающаяся сверху область уведомлений со строкой поиска). На это мне есть что сказать: я прекрасно понимаю природу гнева гномовода по поводу глобального меню в KDE. Причина здесь в зависти и бессильной злобе от того, что в конкурирующем настольном окружении хорошо работают штуки, которых в Gnome нет и в ближайшее время точно не будет. У нас есть KRunner (лучшая в своём классе реализация HUD), но самое главное — в KDE меню приложений можно настраивать. Его можно оставить в окне самого приложения, можно закинуть в кнопку в заголовке окна, можно вынести в отдельный плазмоид на панель, можно вообще отключить. Любой, кто пытался освоиться в Gnome Shell, может подтвердить убогость, бедность и малую информативность как оболочки в целом, так и отдельных GTK3-программ. Пользователь Gnome не видит какие программы у него запущены, но он также не видит функций по управлению документом, открытым в GTK3-программе до тех пор, пока не перейдёт к этой программе. Эта «слепота» приводит к тому, что в Gnome нужно тратить дополнительное время на то чтобы постоянно переключаться между обзором запущенных программ и рабочим приложением, а потом отдельно искать, где у приложения меню (и есть ли оно там вообще). Современные тенденции в развитии GTK3 приводят также к тому, что цельность таких рабочих окружений как XFCE и Mate размывается и становится эклектичной. Говоря по-русски, вместо продуманного рабочего стола вы рискуете получить помойку, щедро сдобренную фантазиями дизайнеров Gnome. По этой, и по многим другим причинам, KDE Plasma — лучший рабочий стол на сегодняшний день.

I have started porting the code in librsvg that parses SVG's CSS properties from C to Rust. Many properties have symbolic values:

stroke-linejoin: miter | round | bevel | inherit

stroke-linecap: butt | round | square | inherit

fill-rule: nonzero | evenodd | inherit

StrokeLinejoin is the first property that I ported. First I had to write a little bunch of machinery to allow CSS properties to be kept in Rust-space instead of the main C structure that holds them (upcoming blog post about that). But for now, I just want to show how this boiled down to a macro after refactoring.

First cut at the code

The stroke-linejoin property can have the values miter, round, bevel, or inherit. Here is an enum definition for those values, and the conventional machinery which librsvg uses to parse property values:

#[derive(Debug, Copy, Clone)]
pub enum StrokeLinejoin {
    Miter,
    Round,
    Bevel,
    Inherit,
}

impl Parse for StrokeLinejoin {
    type Data = ();
    type Err = AttributeError;

    fn parse(s: &str, _: Self::Data) -> Result<StrokeLinejoin, AttributeError> {
        match s.trim() {
            "miter" => Ok(StrokeLinejoin::Miter),
            "round" => Ok(StrokeLinejoin::Round),
            "bevel" => Ok(StrokeLinejoin::Bevel),
            "inherit" => Ok(StrokeLinejoin::Inherit),
            _ => Err(AttributeError::from(ParseError::new("invalid value"))),
        }
    }
}

We match the allowed string values and map them to enum values. No big deal, right?

Properties also have a default value. For example, the SVG spec says that if a shape doesn't have a stroke-linejoin property specified, it will use miter by default. Let's implement that:

impl Default for StrokeLinejoin {
    fn default() -> StrokeLinejoin {
        StrokeLinejoin::Miter
    }
}

So far, we have three things:

• An enum definition for the property's possible values.
• impl Parse so we can parse the property from a string.
• impl Default so the property knows its default value.

Where things got repetitive

The next property I ported was stroke-linecap, which can take the following values:

#[derive(Debug, Copy, Clone)]
pub enum StrokeLinecap {
    Butt,
    Round,
    Square,
    Inherit,
}

This is similar in shape to the StrokeLinejoin enum above; it's just different names.

The parsing has exactly the same shape, and just different values:

impl Parse for StrokeLinecap {
    type Data = ();
    type Err = AttributeError;

    fn parse(s: &str, _: Self::Data) -> Result<StrokeLinecap, AttributeError> {
        match s.trim() {
            "butt" => Ok(StrokeLinecap::Butt),
            "round" => Ok(StrokeLinecap::Round),
            "square" => Ok(StrokeLinecap::Square),
            "inherit" => Ok(StrokeLinecap::Inherit),

            _ => Err(AttributeError::from(ParseError::new("invalid value"))),
        }
    }
}

Same thing with the default:

impl Default for StrokeLinecap {
    fn default() -> StrokeLinecap {
        StrokeLinecap::Butt
    }
}

Yes, the SVG spec has

default: butt

somewhere in it, much to the delight of the 12-year old in me.

Refactoring to a macro

Here I wanted to define a make_ident_property!() macro that would get invoked like this:

make_ident_property!(
    StrokeLinejoin,
    default: Miter,

    "miter" => Miter,
    "round" => Round,
    "bevel" => Bevel,
    "inherit" => Inherit,
);

It's called make_ident_property because it makes a property definition from simple string identifiers. It has the name of the property (StrokeLinejoin), a default value, and a few repeating elements, one for each possible value.

In Rust-speak, the macro's basic pattern is like this:

macro_rules! make_ident_property {
    ($name: ident,
     default: $default: ident,
     $($str_prop: expr => $variant: ident,)+
    ) => {
        ... macro body will go here ...
    };
}

Let's dissect that pattern:

macro_rules! make_ident_property {
    ($name: ident,
//   ^^^^^^^^^^^^ will match an identifier and put it in $name

     default: $default: ident,
//            ^^^^^^^^^^^^^^^ will match an identifier and put it in $default
//   ^^^^^^^^ arbitrary text

     $($str_prop: expr => $variant: ident,)+
                       ^^ arbitrary text
//   ^^ start of repetition               ^^ end of repetition, repeats one or more times

    ) => {
        ...
    };
}

For example, saying "$foo: ident" in a macro's pattern means that the compiler will expect an identifier, and bind it to $foo within the macro's definition.

Similarly, an expr means that the compiler will look for an expression — in this case, we want one of the string values.

In a macro pattern, anything that is not a binding is just arbitrary text which must appear in the macro's invocation. This is how we can create a little syntax of our own within the macro: the "default:" part, and the "=>" inside each string/symbol pair.

Finally, macro patterns allow repetition. Anything within $(...) indicates repetition. Here, $(...)+ indicates that the compiler must match one or more of the repeating elements.

I pasted the duplicated code, and substituted the actual symbol names for the macro's bindings:

macro_rules! make_ident_property {
    ($name: ident,
     default: $default: ident,
     $($str_prop: expr => $variant: ident,)+
    ) => {
        #[derive(Debug, Copy, Clone)]
        pub enum $name {
            $($variant),+
//          ^^^^^^^^^^^^^ this is how we invoke a repeated element

        }

        impl Default for $name {
            fn default() -> $name {
                $name::$default
//              ^^^^^^^^^^^^^^^ construct an enum::variant

            }
        }

        impl Parse for $name {
            type Data = ();
            type Err = AttributeError;

            fn parse(s: &str, _: Self::Data) -> Result<$name, AttributeError> {
                match s.trim() {
                    $($str_prop => Ok($name::$variant),)+
//                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expand repeated elements

                    _ => Err(AttributeError::from(ParseError::new("invalid value"))),
                }
            }
        }
    };
}

Getting rid of duplicated code

Now we have a macro that we can call to define new properties. Librsvg now has this, which is much more readable than all the code written by hand:

make_ident_property!(
    StrokeLinejoin,
    default: Miter,

    "miter" => Miter,
    "round" => Round,
    "bevel" => Bevel,
    "inherit" => Inherit,
);

make_ident_property!(
    StrokeLinecap,
    default: Butt,   // :)

    "butt" => Butt,
    "round" => Round,
    "square" => Square,
    "inherit" => Inherit,
);

make_ident_property!(
    FillRule,
    default: NonZero,

    "nonzero" => NonZero,
    "evenodd" => EvenOdd,
    "inherit" => Inherit,
);

Etcetera. It's now easy to port similar symbol-based properties from C to Rust.

Eventually I'll need to refactor all the crap that deals with inheritable properties, but that's for another time.

Conclusion and references

Rust macros are very powerful to refactor repetitive code like this.

The Rust book has an introductory appendix to macros, and The Little Book of Rust Macros is a fantastic resource that really dives into what you can do.

Following my last blog about Krafts upcoming release 0.80 I got a lot of positive reactions.

There was one reaction however, that puzzles me a bit and I want to share my thoughts here. It is about a comment about my announcement that I prefer to continue to develop Kraft on Github. The commenter reminded my friendly that there is still Kraft code on KDE infrastructure, and that switching to a different repository might waste peoples time when they work with the KDE repo.

That is a fair statement, of course I don’t want to waste peoples time. What sounds a bit strange to me is the second paragraph, that says that if I decide to stay with Github, I should let KDE people know that I wish Kraft to not be a KDE project anymore.

But … I never felt that Kraft should not be a KDE project any more.

A little History

Kraft has come a long way together with KDE. I started Kraft in (probably) 2004, gave a talk about Kraft at the Akademy Dublin 2006, maintained it with the best effort I could contribute until today. There is a small but loyal community around Kraft.

During all the time I got little substancial contribution to the code directly, with the exception of one cool developer who got interested for some time and made some very interesting contributions.

When I asked a for the subdomain http://kraft.kde.org long time ago I got the reply that it is not in the interest of KDE to give every little project a subdomain. As a result I reserved http://volle-kraft-voraus.de and run it since then, happily showing a “Part of the KDE family” logo on it.

Beside the indirect contributions to libraries that Kraft uses, I shipped Kraft with the translations made by the KDE i18n team, for which I always was very grateful. Otherwise I got no other services from KDE.

Why Github?

Githubs workflow serves me well in my day job, and since I have only little time for Kraft, I like to use the tools that I know best and give me the most efficiency.

I know that Github is not free software and I am sceptical about that. But Github also does not lock in, as we still are on git. We all know the arguments that usually come on the table at this point, so I am not elaborating here. One thing I want to mention though is that since I moved to Github publically I already got two little pull requests with code contributions. That is a lot compared to what came in the last twelfe years when living on KDE infrastructure only.

Summary

Kraft is a small project, driven by me alone. My development turnaround is good with Github as I am used to it. Even if no KDE developer would ever look at Github (which I know is not true) I have to say with heavy heart that Kraft would not take big harm by leaving KDEs infra, based on the experience of the last 12 years.

If the KDE translation teams do not want to work with Github, I am fine to accept that, and wonder if there could be a solution rather than switching to Transifex.

One point however I like to make very clear: I did not wish to leave KDE, nor aimed to move Kraft out. I still have friends in the KDE community, I am still very interested in free software on desktop and elsewhere, and my opinion is still that KDE is the best around.

If the KDE community feels that Kraft must not be a KDE project any longer because it is on Github, ok. I asked KDE Sysadmins to remove Kraft from the KDE git, and it is already done.

Kraft now lifes on on Github.

Gitlab has a fairly conventional Continuous Integration system: you push some commits, the CI pipelines build the code and presumably run the test suite, and later you can know if this succeeded of failed.

But by the time something fails, the broken code is already in the public repository.

The Rust community uses Bors, a bot that prevents this from happening:

• You push some commits and submit a merge request.

• A human looks at your merge request; they may tell you to make changes, or they may tell Bors that your request is approved for merging.

• Bors looks for approved merge requests. It merges each into a temporary branch and waits for the CI pipeline to run there. If CI passes, Bors automatically merges to master. If CI fails, Bors annotates the merge request with the failure, and the main repository stays working.

Bors also tells you if the mainline has moved forward and there's a merge conflict. In that case you need to do a rebase yourself; the repository stays working in the meantime.

This leads to a very fair, very transparent process for contributors and for maintainers. For all the details, watch Emily Dunham's presentation on Rust's community automation (transcript).

For a description of where Bors came from, read Graydon Hoare's blog.

Bors evolved into Homu and it is what Rust and Servo use currently. However, Homu depends on Github.

I just found out that there is a port of Homu for Gitlab. Would anyone care to set it up?

Update: Two people have suggested porting Bors-ng to Gitlab instead, for scalability reasons.