
Towards a Rust Foundation - eitland
http://smallcultfollowing.com/babysteps/blog/2020/01/09/towards-a-rust-foundation/
======
caniszczyk
I have a lot of experience in building open source foundations, from my time
at Apache, Eclipse and the Linux Foundation, lots of pros and cons across
different entities in terms of how much professional help you want (versus
volunteer labor). I generally don't recommend standing up your own foundation
from scratch unless you're extremely well funded. The Linux Foundation
essentially offers "Foundation as a Service" for projects. It hosts a variety
of projects and organizations, from LetsEncrypt.org, to Kubernetes (CNCF) to
GraphQL to NodeJS (OpenJS) to the R Consortium and more. I created a
presentation here not so long ago about the process/benefits:
[https://www.slideshare.net/caniszczyk/bringing-an-open-
sourc...](https://www.slideshare.net/caniszczyk/bringing-an-open-source-
project-to-the-linux-foundation-206551742)

I'm happy to have a conversation if you ever wanted to chat more about the
details.

~~~
steveklabnik
I saw you posted this in other places too. Several of us have some LF
experience, so we're already broadly familiar, but I appreciate it! We'll
reach out if appropriate, thanks!

~~~
caniszczyk
Thanks, I believe you're based in Austin also so happy to do coffee (unless
I'm wrong)

~~~
steveklabnik
I am! If you ever want to get coffee about non-LF stuff, let me know :)

~~~
mylesborins
you two are both rad and this is the best interaction I've seen on the orange
site in a while

~~~
bordercases
Because it's almost contentless?

~~~
steveklabnik
It’s just a bit inside baseball; Myles is on the Node TSC, which is an organ
of the Linux Foundation via the Node Foundation.

------
rectang
> _should the Foundation be a 501(c)(3) (a non-profit, in other words) or
> not?_

If you go the independent foundation route, choosing 501(c)(3) would be in
keeping with the stated priority to have Rust's governance be independent.
This makes it more difficult for corporations to control the foundation's
direction through insisting that their donations be used for specific
purposes, because donations to a 501(c)(3) cannot unduly advantage any
commercial entity.

ETA: There are different types of "non-profit" organizations under IRS code
501. 501(c)(3) is a "Charitable Organization", and donations are tax
deductible. (Tax-deductible donations cannot be used to unduly advantage a
commercial entity because if they were, the business could avoid paying taxes
on funds they use to further their own initiatives.) 501(c)(6) is a "Business
League", where donations are _not_ tax deductible, so donors have much more
leverage.

~~~
codesections
The problem with trying to become a 501(c)(3) nonprofit is that you have to
show a "charitable purpose", which can sometimes be hard to do ("supporting
open-source software" is _not_ a valid charitable purpose under current US
law, sadly enough) [not legal advice]

~~~
wrycoder
Educational 501(c)(3) foundations meet that requirement.

~~~
tyre
I don't think this foundation would qualify.

I'm so incredibly not a lawyer, but my understanding is that educational
501c3s need to be predominately educational, in that they have classes and a
physical location.

If the primary purpose of the Rust foundation is open source code and
standardizing the language, it's not exactly educational.

~~~
benji-york
For what it's worth, the Python foundation is a 501(c)3:
[https://www.python.org/psf/](https://www.python.org/psf/)

------
zapita
An independent foundation for Rust makes a lot of sense. No doubt the Linux
Foundation will pounce on this opportunity to absorb yet another project into
its orbit... I would prefer if Rust steered clear of LF / CNCF if possible.
Their governance and financials are opaque, they prioritize corporate sponsors
and fancy events at the expense of every other priority, and there is already
too much power concentrated in a very small group of people.

The Linux Foundation / CNCF people will tell you that it's really hard to
setup a foundation, and you should leave it up to them. I don't think that's
actually true. In my opinion LF gets much more value out of projects (through
compounded brand value and revenue opportunities) than the other way around.

Nothing terrible will happen if you go with them... but nothing amazing will
happen either. You will get the bare minimum support and infrastructure, and
nothing more. Meanwhile, a few people who don't actually contribute any open-
source code will benefit immensely from the Rust brand.

EDIT: I just realized that the Linux Foundation people are already on this
thread making their sales pitch...

------
kick
A classic example of this going wrong is the Gentoo Foundation. Not only did
it make them lose the founder of Gentoo (which, admittedly, isn't as much of a
problem with Rust: Hoare has already moved on to bigger things), but it caused
a variety of organizational troubles that still can be seen in Gentoo today.

Hope this goes well!

------
M2Ys4U
> should the Foundation be a 501(c)(3) (a non-profit, in other words) or not?

This seems to imply that the US is the only place a foundation would be
incorporated? Other jurisdictions may have more favourable legal regimes.

------
ChrisSD
Note that this proposal is not about changing the governance of Rust the
language. That is and will remain the responsibility of an independent group.
This is purely about handling administration of the Rust project and having a
legal entity which can sign contracts, hold trademarks, own domain names, etc.

~~~
rectang
Depending on how you set up administration, independent governance can become
difficult to sustain. The more money you take from donors, especially
"directed" donations with strings attached, the harder it is.

For example, you may fear offending a donor who wants to use the "Rust"
trademark for their megabudget conference where they sell themselves as the
preeminent Rust experts.

This comes into play if you consider funding development directly through a
foundation, which requires large donations.

~~~
pietroalbini
Yeah, that's why I'd prefer for the Rust Foundation to be as lean as possible,
explicitly excluding raising donations for the whole project and paying
developers from its scope. Funding development could then be done by other
entities, not related to the foundation.

[https://internals.rust-lang.org/t/blog-post-towards-a-
rust-f...](https://internals.rust-lang.org/t/blog-post-towards-a-rust-
foundation/11601/17)

------
qaq
I think hiring of devs might be good long term though provided funding is
there. There are always areas which might not be something people would work
for fun on but which might be important to ecosystem.

~~~
TheSoftwareGuy
Does Mozilla (the current steward of the the language, as is my current
understanding) not currently pay devs to work on Rust?

~~~
steveklabnik
Framing Mozilla as the “steward of the language” is one reason why we’re
making this move. Don’t get me wrong, Mozilla is important to Rust, but (in
all things other than the trademark, which is a nuclear option they’ve given
no indication of ever using) the relationship is much more of a “large
supporter of” then “in control of” one. Having a foundation would make this
much more clear to folks who aren’t deeply involved in Rust.

~~~
duregin
Didn't you sort of have a falling-out type of experience with Mozilla? Does
that have any effect on this move?

~~~
steveklabnik
From the very beginning, the folks sponsoring the Rust effort from within
Mozilla made sure that Mozilla couldn't directly control things. And Mozilla
also just isn't that kind of organization to begin with, honestly.

These conversations have been going on a _long_ time. This particular
iteration of this conversation started before I left Mozilla. It has nothing
to do with me personally, regardless of that relationship.

I have long (before, during, and after my employment at Mozilla) have thought
that an independent foundation would be excellent for Rust, but am worried
about the details. Foundations require active administration, which is even
more work. And it's unclear who does that work. I think that we've grown to
the point where it very well make sense now, though.

------
stmw
The time is right for this step, Rust will benefit from having a proper
umbrella organization. Also, it's a very well-writen post on what could be a
boring topic.

------
phkahler
I'd prefer the evolution of Rust to slow down and stabilize. More like C and
much less like C++.

~~~
fluffything
Do you have an example of a programming language that's both widely-used and
does not evolve ? Even C has a new standard every 3-5 years nowadays.

~~~
hu3
A recent example.

Go values not breaking current code much more than adding features.

~~~
pjmlp
Yet even Go has several new features not present in version 1.0 and 2.0
roadmap is underway.

Languages are software products, they are evolve to fulfill the market needs
or they die.

~~~
hu3
Adding features? Sure, as long as current code keeps compiling.

~~~
pjmlp
Even C removes features from time to time.

ANSI C compilers are not required to still support K&R C, Annex K was
compulsory on C99, became optional on C11, gets() was removed, some semantics
corrected,....

------
burfog
The major serious languages get along just fine with IEEE, ANSI, and ISO.

For example, C is handled by ISO/IEC JTC1/SC22/WG14.

The idea that Rust would need a foundation is making me uneasy.

~~~
steveklabnik
The Rust project has much more things under its wings than the C ISO group
does. It’s a superset.

The Rust project sees Rust as more than just purely a language. For example,
the C ISO group doesn’t run any web facing infrastructure, with all of the
legal and financial obligations that implies, nor do they develop compilers,
with all of the CI/hosting infrastructure that implies.

They’re just different in scope, which has been true for all of Rust’s
lifetime.

~~~
burfog
That is common for toy languages without wide industry support. It doesn't
inspire confidence.

There should be compilers from Microsoft, IBM, Apple, GNU/FSF, and several
others. There should be a properly ratified international standard that
describes the language. There should be support from 16-bit microcontrollers
to mainframes.

Languages like C have lots of web facing infrastructure. It just isn't all run
by one entity. The eggs are not in one basket.

~~~
oblio
How many languages outside of C, C++ and amusingly, old versions of C# fit
that? Not that many that I can think of. Maybe Ada, Javascript?

Java isn't officially standardized (ISO or such), neither are C# nor Python,
Ruby, etc.

------
phkahler
I'd prefer the evolution of Rust to slow down and stabilize. More like C and
much less like C++. OTOH there are a few things I feel the language needs.
Better control of memory layout, and a stable ABI in particular, so it can
become a good foundation for more libraries and infrastructure.

~~~
fluffything
Rust already provides a stable ABI via `repr(C)` types and `extern "C"`
functions.

~~~
unlinked_dll
And memory layout through repr(align). I also disagree that rust should slow
down. There are a number of critical features that need to land for the
language should “stabilize” (it is stable).

~~~
phkahler
I agree a few more things need to get in. But AFAICT the abi is not stable and
you may need to recompile all dependencies when updating the compiler.

I would like it to be "feature complete" without having regular churn like
C++. Or the recent battle with Python that was a sort of last straw for Guido.
C is almost completely stagnant and that's a good thing. Posix as well. If you
want to be a long term systems language it seems stability is a critical
feature and Rust needs to get that in the next few years. IMHO or course.

~~~
unlinked_dll
C++ didn’t have a pragmatically stable ABI until like a year ago on MSVC. You
had to jump through hoops with extern C APIs or COM and the like. The same is
true in Rust, and even in C++ with different tool chains on windows.

The only language with a stable ABI is C (and that is more accidental than
explicit). It’s too hard a guarantee to provide with little ROI when you have
a workaround, and it chains your implementation to ABI details.

Just as an example, rustc is very clever about struct layout and liberally
pads fields to get superior alignment. This may change in the future depending
on architectures and paradigms. You don’t want your ABI to define a padding
scheme for your targets today, you want future compilers to be smarter.

If you want to guarantee stability you need to align the memory manually on
the structs that cross ABI boundaries like shared libraries, and any kind of
language construct that lets you do future tricks with ABI within a binary but
provides escape hatches for things along the boundary would look identical to
how you do things today via attributes.

TL;DR ABI stability in the compiler is simply not desirable. You can already
do it manually and you should do it manually. It’s fairly ergonomic as well.

~~~
the_why_of_y
Interesting, I wasn't aware that Microsoft documents the ABI compatibility for
MSVC 2015-2019.

[https://docs.microsoft.com/en-us/cpp/porting/binary-
compat-2...](https://docs.microsoft.com/en-us/cpp/porting/binary-
compat-2015-2017?view=vs-2019)

Furthermore, GCC/libstdc++ have maintained ABI compatibility for at least 15
years now, even across an incompatible change of std::string and std::list
required for C++11 conformance, so in practice the situation with C++ looks
better than with Rust.

[https://developers.redhat.com/blog/2015/02/05/gcc5-and-
the-c...](https://developers.redhat.com/blog/2015/02/05/gcc5-and-the-c11-abi/)

------
neiman
I assume it may not be a popular opinion here, but it would be so much easier
if projects like Rust could have a DAO (decentralized autonomous organization)
instead of a foundation, and a blockchain account managed by this DAO instead
of a bank account.

The main issues I see with this idea are volatility of cryptocurrencies
prices, inability of paying with cryptocurrencies in most cases atm,
environmental issues regarding the blockchain and the infantry of DAO
governing models.

But as an abstract idea I believe DAOs will replace foundations at some point
in the future, making such discussions much easier.

~~~
zozbot234
The really nice thing about making Rust a DAO is that the legal code can
literally be written in Rust ;-P

~~~
frenchyatwork
This comment should probably have a trigger warning.

