How the most underrated contributor saved Rust from death

Dave Herman, Rust’s most underrated contributor

Original author – Brian Anderson… It also has to do with working on the Rust language. It is clear that in his article he will praise this language, but something else is more important: it reveals the inner workings of the project. Anderson talks about his first few years working on Rust at Mozilla. He wants to restore justice by remembering an outstanding but humble mentor and engineer who, in many ways, decided the fate of the project.

I think Rust is clearly on the rise right now. I remember how much needed to be done right to achieve success. The team repeatedly made fateful decisions in which they were not completely sure. Every wrong decision could lead the project to failure. Sometimes we just didn’t know the correct answer. But in each such situation, it was as if a small miracle happened, and the project moved on. Of course, these “miracles” did not happen out of nowhere: we were helped by the intuition of several very experienced professionals who were passionate about the project and really wanted to create something cool.

At different times, many have worked on the project. But here we will talk about one of the key members of the team, who, in my opinion, was very quickly and undeservedly forgotten.

Mozilla Research

By 2009, Mozilla had received a large sum of money from a lucrative deal with Google (it became the default search engine in the Firefox browser). And, as I understand it, it was at this point that Mozilla’s management decided to invest in new projects.

This is how the division – Mozilla Research was born. His task was to develop pilot projects in conjunction with the academic IT community.

The most famous among such projects are the Rust programming language and the new browser engine. Servo…

Among others, Dave Herman was brought in to lead the division. I will talk about him until the end of the article.

Who is Dave Herman?

Dave Herman is a programming language theorist and, as I call him, a macrophile (someone who loves macros a lot). He was one of Mozilla’s representatives on the ECMAScript Commission. He and Graydon Hoare, the main developer of Rust, were working together on the ECMAScript 4 standard at the time. Both were eager to create a new programming language.

Although Hoare is credited with being the creator of Rust, Herman was a major influence on many key decisions. Below I will describe everything I remember about this.

What exactly did Dave Herman do for Rust?

Although Rust was announced in June 2010, work on it inside Mozilla actually began in late 2009. The only public record of that stage of development is currently in the repository. rust-prehistory…

A few months before Rust was presented to the public at the Mozilla Summit 2010, the team hastily refined it. It can be seen that Dave’s contribution to this work is difficult to underestimate:

~ / rust-prehistory $ git shortlog -sn

1156 Graydon Hoare

163 Andreas Gal

104 Dave Herman

59 graydon@pobox.com

55 Patrick Walton

37 Graydon Hoare ext: (% 22)

13 Roy Frostig

9 graydon@mozilla.com

6 Brendan Eich

5 Michael Bebenita

1 Brian Campbell

Dave’s strategy

After that, he almost stopped writing code and for several years worked with the team in a different role – as a more experienced mentor, mastermind and analyst.

At the time, most of the people working on Rust worked in the same office (with the exception of Graydon, who was remote) and regularly gathered at a table in a small conference room at Mozilla’s Mountain View headquarters. The team consisted of full-time employees, an ever-changing crowd of interns and Dave Herman himself.

I guess he saw himself as a mentor, gently nudging the team into productive interaction, based on his own experience with ECMAScript and his own understanding of programming language development. But, at the same time, he never pushed for solutions at the expense of his authority and to this day does not try to claim anything in Rust.

His strategy was to become a “gray eminence” in the best sense of the word.

The team discussed various issues. Today, some of them seem strange or unnecessary, and the answers to them are obvious, trivial: “What keyword should I use to return a result from a function?” But some questions really make you think seriously: “How to safely store a pointer to a structure field?”

The fact is that in the process of developing a language, every little thing matters a lot. This made it very difficult to avoid collisions during the design phase. Therefore, Rust was formed gradually and was constantly rewritten – until all the puzzles were formed into a single picture. Dave was one of the few team members with extensive experience in programming language design. And, probably, work on Rust would have turned into chaos if he did not lead the team in his unobtrusive manner. He structured the process, asked the right questions, and formulated high priority issues at the current time.

Worldview

We can say that Dave’s worldview shaped the worldview of the entire team and the Rust language itself. And that’s why Dave was most often pleased with the team’s decisions.

Dave had a say in all discussions. But he was especially interested in several topics:

“Pedagogical component”
In addition to being an engineer, Dave is also a teacher and mentor. He considered it important that the essence of the technological decisions made could be easily explained to other specialists and the community as a whole. This requirement worked well when a new employee or intern joined the team.
Transparency of processes and community development
Rust has developed from the very beginning as an open source project. I think Dave’s experience on the ECMAScript standardization committee has a lot to do with this. He believed that the most successful languages are developed by a large group of people and companies who find a compromise between their own motives and interests.

Therefore, the Rust development process needed to be made as open to any stakeholder participation as was reasonable at the time. For example, much of the early Rust process was documented in published minutes meetings. I’m sure this is Dave’s merit: many of these minutes were recorded by him personally.

Probably the development of the Rust community is Dave’s most important achievement on this project. This also influenced its viability.

Macros
As I wrote above, Dave is a fan of macros. He has vast experience in development in the language Racket (a general-purpose multi-paradigm programming language belonging to the Lisp / Scheme family).

Under Dave’s guidance, interns have added declarative macros (macro_rules!) To Rust. I remember that he and Paul Stansifer (who was a trainee at the time) spent many hours discussing how to neatly implement the macro system, moving from the Lisp family to the C-like family of languages like Rust.

Significantly, Dave was also a big influence in transforming Rust from an operator language to an expression language.

Selection of valuable specialists and saving the project from death

Dave brought Niko to the company, who developed the ownership system for Rust. It was Dave who hired Yehudu Katzawho created the Cargo functionality recognizer.

In addition, Dave played another important role: when it looked like Rust was in danger of being shut down, he defended the project before Mozilla’s leadership.

At first we were surprised that Mozilla had given so much money for this project. But while we were working on Rust within the walls of the company, it often seemed to us that the project could be closed at any time. It got especially scary when the CEO and former chief engineer of Mozilla, Brendan Eich (who is also an active member of the Rust team), left the company. This was one of the reasons why it was necessary to rather create a large community around the language. We understood that time is ticking and irreparable things can happen at any moment.

However, Dave has always believed in Rust. He did everything he could to save the project. He developed the community, repeatedly asked management for time and tried to strengthen the team. In fact, I don’t know everything he had to face. But the main thing is that we continued to work on Rust, and the team did not shrink and even grew from time to time.

However, the project has always lacked developers. I remember how angry I was: how could we compete with Google and Apple with such a small staff of engineers? Part of the solution to this problem came down to building an interested and diverse community of contributors. But this is a slow and unpredictable process. Dave suggested a better solution: take interns; many interns.

As a result, we have more interns than full-time employees. Dave brought them all. Rust was created with active student participation, and many of them interned at Mozilla. This subsequently became part of the development strategy of the entire Mozilla Research division.

And after that, you say that Dave Herman has done little for Rust?

What happened next?

Dave’s active involvement with Rust ended around 2014-2015. Most likely, most of the Rust community outside of Mozilla never knew about its existence.

Dave was not the main Rust developer. After the Rust language was introduced to a wide audience, it made just six commits to the public repository. He submitted his changes to the mailing list only four times.

But he formed a team that, in his opinion, created something extraordinary. Dave gently instilled in this team the values and standards that would allow Rust to evolve outside of Mozilla, regardless of individual input.

In early February 2021, Google, Microsoft, AWS, Huawei, Mozilla launched the Rust Foundation, a non-profit organization. She will be responsible for developing the ecosystem and supporting the developers of the Rust language, as well as sponsoring the project.

Cloud servers from Macleod suitable for Rust development.

Register using the link above or by clicking on the banner and get a 10% discount for the first month of renting a server of any configuration!