So far, we have learned the basics of Rust syntax, developed a custom Kubernetes controller, and integrated with the front-end with Wasm.

This is the 7th post in the Start Rust focus series. Other posts include:

• My first cup of Rust
• My second cup of Rust
• The Rustlings exercises — part 1
• The Rustlings exercises — part 2
• Rust on the front-end
• A Rust controller for Kubernetes
• Rust and the JVM (this post)

I’ve been using the JVM for two decades now, mainly in Java. The JVM is a fantastic piece of technology. IMHO, its most significant benefit is its…

To teach myself Kubernetes in general and controllers in particular, I previously developed one in Java. This week, I decided to do the same in Rust by following the same steps I did.

1. My first cup of Rust
2. My second cup of Rust
3. The Rustlings exercises — part 1
4. The Rustlings exercises — part 2
5. Rust on the front-end
6. A Rust controller for Kubernetes (this post)

The guiding principle

The guiding principle is creating a Kubernetes controller that watches pods’ lifecycle and injects a sidecar into them. …

Up until now, JavaScript has been the only ubiquitous language available in browsers. It has made JavaScript much more popular than its design (and its associated flaws) would have allowed. Consequently:

• The number of JavaScript developers has grown tremendously and steadily
• The ecosystem around front-end JavaScript has become larger and much more complex
• The pace of changes has increased, so that developers complain about JavaScript fatigue
• Interestingly enough, JavaScript sneaked on the back-end via Node.js
• etc.

I don’t want to start a holy war about the merits of JavaScript, but IMHO, it only survived this far because of its role…

Last week, I dived into the Rustlings exercises. It was a bit long, and I decided to split my understanding into two different posts. Now is the time to finish them.

This is the 4th post in the Start Rust focus series.Other posts include:

1. My first cup of Rust
2. My second cup of Rust
3. The Rustlings exercises — part 1
4. The Rustlings exercises — part 2 (this post)

Threading

There’s a single exercise for threads. It’s a bit disappointing because it’s a weak point of mine: I’d have loved more practice.

The solution is to wrap the JobStatus structure into a…

One of the talks in my current portfolio is Migrating from Imperative to Reactive. The talk is based on a demo migrating from Spring WebMVC to Spring WebFlux in a step-by-step approach. One of the steps involves installing BlockHound: it allows to check whether a blocking call occurs in a thread it shouldn’t happen and throws an exception at runtime when it happens.

I’ve presented this talk several times in the previous week, both in its Java version and its Kotlin one. One such presentation was at Javaday Istanbul. After the talk, one of the questions I received was, “How…

To continue building my understanding of Rust, I searched for some simple Rust exercises. Hence, I dedicated my weekly personal work time to the Rustling exercises.

Greetings and welcome to rustlings. This project contains small exercises to get you used to reading and writing Rust code. This includes reading and responding to compiler messages!

— https://github.com/rust-lang/rustlings

I believe that this workshop is pretty neat. Thanks to everybody who contributed to it! I’ll split my notes into two posts, as Rustlings contain many (many!) exercises. Besides that, I need to learn about the more advanced themes such as threading. In those…

Last week, I drank my first cup of Rust. I learned concepts that are foreign in the languages I know: ownership, borrowing and lifetimes. This week I want to drink the second cup and see where it leads me.

Self-referencing types

It’s time to implement another exercise from the initial exam:

Given a collection of Super, return the sub-collection of those who have a sidekick.

We need to change the model to add a sidekick attribute of type Super.

It all started with an informal chat with my friend Anthony. We were talking about languages, and I said that I preferred compiled ones. He then went on to mention Rust. We admitted that we were too afraid to learn it because of its perceived complexity.

After the chat, I thought about it, and I wondered why I didn’t check by myself. I did. And I became interested.

There are tons of resources on the Web on how to learn Rust. This post is a memo of the steps I followed. …