5min read

Experimenting with Rust


Since the very beginning we have our own CI infrastructure. Initially we had Jenkins, now we proudly operate on GitLab. Nevertheless, a CI system is not enough: CD is a must for us to distribute our builds for testing. That’s why some time ago we developed a Ruby gem which is responsible for a couple of things: extracting iOS/Android artifacts from builds, uploading them into our servers and notifying third parties about it. The quality of this script is fine, but not as perfect as we would wish. So we decided to rewrite it.


We wanted the new CD application to be: fast, reliable, easily extensible and deployable on various platforms (Linux/OS X). I wanted to write it in a modern, statically typed language.

Fast and static typing requirements excluded languages that usually are used in this kind of tasks: python, ruby, etc. Javascript wasn’t considered, sorry.

Swift - this was our first choice, but it quickly turned out it’s not yet available on other platforms than OS X. After some discussions and the inspiring attitude of Wojtek Erbetowski (our Head of Engineering) we made a verdict: Rust.

Rust is a compiled programming language developed by Mozilla Research and officially announced in 2010. It’s open source as well, so the language design is refined by the community. Version 1.0 was released in May 2015 and new releases are being published in a six weeks cycle.


Among lots of impressions about the language I’d like to touch four topics:

  • memory safety,
  • language structures,
  • friendly compiler,
  • package manager.

Memory safety

The core of Rust’s memory policy is driven by the idea of ownership and borrowing.

Each variable is created on stack by default (just like in C) and the current scope owns it. You can pass this variable to a function, but then it will take the ownership of the variable and you won’t be able to use it in the current scope. Let’s visualize this.

let a = 1;
do_something(a); // Function takes the ownership.
let b = a + 1;  // Error! You can't use `a` anymore.

How to make it work? You have to borrow a, so we have to pass a reference to the variable. let keyword means that a is immutable by default, so if we want to allow our function to modify a it has to be instantiated a little bit differently.

let mut a = 1;   // `mut` keyword enabled mutability.
do_something(&a); // Reference is passed.
let b = a + 1;   // This will work.

(Update: Actually, even the first example will compile, because 1 is a primitive Int type that implements Copy trait, which means that 1 will be copied when passed. With more complex types, like String, you can use the clone() method to make a copy.)

Seems a little bit crazy, doesn’t it? But thanks to this the language is incredibly reliable in terms of memory management. And this is just the tip of the iceberg. E.g. a shared pointer to a mutable type T allocated on the heap would look like this: Rc<RefCell<T>>.

Rust is designed to be safe, especially in two areas: memory and concurrency. All potential issues are detected during compilation, so it’s almost impossible to write dangerous code.

Language structures

Rust is not an object oriented programming language. You will not find classes hierarchy here (not even the class keyword), polymorphism or runtime features. This may be quite confusing for most of programmers who are very used to think in an OOP way.

The basic data structure is struct, which behaves like a standard class but cannot be inherited. trait means the interface. A trait may derive from other traits. struct can implement multiple traits. There’s an enum type as well. It can hold different associated types and with the match keyword (similar to switch in other languages) it’s very powerful.

There are generics (templates) as well, but due to the lack of polymorphism they don’t always behave like most object oriented programmers would expect. The generic type is resolved in compile time, i.e. you can’t use two different structs even if they implement the same trait (interface).

Rust is very functional. Every function returns a value even if it’s an empty tuple (). The language operates with iterators, iterator adaptors and consumers, so most built-in data types expose methods like: collect, flatMap, map, filter, etc. This makes the language very clear and expressive.

The basic types that the standard library operates on are two enums: Option and Result. Optionals can have a value or not. Results can hold a success value or an error value. Thanks to this, error handling is very elegant and you will never be surprised by unidentified exception throws or illegible try-catch constructions.

A friendly compiler

The rust complier is called rustc. Amazing tool. This is the first compiler with such a clear and descriptive output I have ever worked with. rustc is not an enemy, but a friend to the programmer. Thanks to good language design, every encountered issue in your code is carefully analyzed and after posting the error, solutions to fix it are suggested. And if you’re not sure about the error you can run rustc --explain E<error number> and you will be provided with a detailed explanation of what’s wrong.

Package manager

The Rust installation contains a built-in package manager, Cargo.

Cargo can create new projects (binary or library) by providing you with a nicely set up standardized directory tree.

Cargo can manage dependencies - in the TOML configuration file you can specify everything you need. If you don’t know the library, just type cargo search <keyword>.

Cargo can run tests - simple cargo test runs unit tests written in source code files, integration tests from the tests directory and tests that are embedded in documentation code example comments.

Using Cargo feels very modern and simple. It’s totally integrated with the language and provides all necessary features that you may expect.


The Rust experiment was a challenge. There were a few moments of crisis, mostly due to my OOP habits and several language concepts that needed to be well understood.

On the other hand writing in Rust is fun. Fun that feels safe but powerful.

On the official website you will find this statement:

Rust is a systems programming language that runs blazingly fast, prevents nearly all segfaults, and guarantees thread safety.

It really is. Give it a try!




Sign in and expect sharp insights, recommendations, ebooks and fascinating project stories delivered to your inbox

The controller of the personal data that you are about to provide in the above form will be Polidea sp. z o.o. with its registered office in Warsaw at ul. Przeskok 2, 00-032 Warsaw, KRS number: 0000330954, tel.: 0048 795 536 436, email: (“Polidea”). We will process your personal data based on our legitimate interest and/or your consent. Providing your personal data is not obligatory, but necessary for Polidea to respond to you in relation to your question and/or request. If you gave us consent to call you on the telephone, you may revoke the consent at any time by contacting Polidea via telephone or email. You can find detailed information about the processing of your personal data in relation to the above contact form, including your rights relating to the processing, HERE.

Data controller:

The controller of your personal data is Polidea sp. z o.o. with its registered office in Warsaw at ul. Przeskok 2, 00-032 Warsaw, KRS number: 0000330954, tel.: [0048795536436], email: [] (“Polidea”)

Purpose and legal bases for processing:


Used abbreviations:

GDPR – Regulation (EU) 2016/679 of the European Parliament and of the Council of 27 April 2016
on the protection of natural persons with regard to the processing of personal data and on the free movement
of such data, and repealing Directive 95/46/EC (General Data Protection Regulation)

ARES – Polish Act on Rendering Electronic Services dated 18 July 2002

TL – Polish Telecommunications Law dated 16 July 2004

1)        sending to the given email address a newsletter including information on Polidea’s new projects, products, services, organised events and/or general insights from the mobile app business world |art. 6.1 a) GDPR, art. 10.2 ARES and art. 172.1 TL (upon your consent)

Personal data:name, email address

2)       statistical, analytical and reporting purposes |art. 6. 1 f) GDPR (based on legitimate interests pursued by Polidea, consisting in analysing the way our services are used and adjusting them to our clients’ needs, as well as developing new services)

Personal data:name, email address

Withdrawal of consent:

You may withdraw your consent to process your personal data at any time.

Withdrawal of the consent is possible solely in the scope of processing performed based on the consent. Polidea is authorised to process your personal data after you withdraw your consent if it has another legal basis for the processing, for the purposes covered by that legal basis.

Categories of recipients:

Your personal data may be shared with:

1)       authorised employees and/or contractors of Polidea

2)       persons or entities providing particular services to Polidea (accounting, legal, IT, marketing and advertising services) – in the scope required for those persons or entities to provide those services to Polidea


Retention period:

1)       For the purpose of sending newsletter to the given email address – for as long as the relevant consent is not withdrawn

2)       For statistical, analytical and reporting purposes – for as long as the relevant consent is not withdrawn

Your rights:


Used abbreviation:

GDPR – Regulation (EU) 2016/679 of the European Parliament and of the Council of 27 April 2016
on the protection of natural persons with regard to the processing of personal data and on the free movement
of such data, and repealing Directive 95/46/EC (General Data Protection Regulation)

According to GDPR, you have the following rights relating to the processing of your personal data, exercised by contacting Polidea via [e-mail, phone].

1)       to access to your personal data (art. 15 GDPR) by requesting sharing and/or sending a copy of all your personal data processed by Polidea

2)       to request rectification of inaccurate personal data
(art. 16 GDPR) by indicating the data requiring rectification

3)       to request erasure of your persona data (art. 17 GDPR); Polidea has the rights to refuse erasing the personal data in specific circumstances provided by law

4)       to request restriction of processing of your personal data (art. 18 GDPR) by indicating the data which should be restricted

5)       to move your personal data (art. 20 GDPR) by requesting preparation and transfer by Polidea of the personal data that you provided to Polidea to you or another controller in a structured, commonly used machine-readable format

6)       to object to processing your personal data conducted based on art. 6.1 e) or f) GDPR, on grounds relating to your particular situation (art. 21 GDPR)

7)       to lodge a complaint with a supervisory authority,
in particular in the EU member state of your habitual residence, place of work or place of the alleged infringement if you consider that the processing
of personal data relating to you infringes the GDPR
(art. 77.1 GDPR)

No obligation to provide data:

Providing your personal data is not obligatory, but necessary for Polidea to provide you the newsletter service

Refusal to provide the above data will result in inability to receive the newsletter service.


In the process of providing the newsletter service, we make decisions in an automated way, including profiling, based on the data you provide.


“Profiling” means automated processing of personal data consisting of the use of your personal data to evaluate certain personal aspects relating to you, in particular to analyze or predict aspects concerning your personal preferences and interests.


The automated decisions are taken based on the analysis of clicked and viewed content. They affect the targeting of specific newsletter content to selected users registered to receive the newsletter service, based on the anticipated interests of the recipient.