
Mozilla releases version 0.1 of the Rust programming language - pcwalton
http://mail.mozilla.org/pipermail/rust-dev/2012-January/001256.html
======
haberman
As a die-hard C guy, Rust is the first "new systems programming language"
since Cyclone and D that I didn't immediately dislike. A lot of really
interesting ideas in here. I'd love to know what Mozilla uses this for
internally.

That said, it's hard to imagine anything displacing C for me. Almost any
systems code I write these days is something I'll eventually want to be able
to expose to a high-level language (Lua, Python, Ruby, etc). To do that you
need code that can integrate into another language's runtime, no matter what
memory management or concurrency model it uses. When you're trying to do that,
having lots of rich concepts and semantics in your systems language (closures,
concurrency primitives, garbage collection) just gets in the way, because you
have to find out how to map between the two. C's lack of features is actually
a strength in this regard.

I do really like Rust's expressiveness though. The pattern matching is
particularly nice, and that is an example of a features that wouldn't "get in
the way" if you're trying to bind to higher-level languages.

~~~
alexatkeplar
Can you elaborate on what (if anything) you immediately disliked about Go?

~~~
haberman
I dislike duck typing; I much prefer to have an explicit declaration of what
interfaces you are implementing. I also think the type system is too dynamic
for a systems language (eg. their answer to generics requires run-time type
checking for every operation).

Also, just as a gut-level reaction I didn't feel excited about any of the
expressiveness that Go offers (compared with my reaction to Rust's pattern
matching, which to me is a clear improvement over how you'd express an
equivalent thing in C or C++).

~~~
ungerik
> their answer to generics requires run-time type checking for every operation

Go has no built in answer to generics. Trying to rebuild generics with other
language features won't make it better.

~~~
haberman
I must have misinterpreted the intent of this from "Go for C++ Programmers":

> Because the conversion is dynamic, it may be used to implement generic
> programming similar to templates in C++. This is done by manipulating values
> of the minimal interface.

I thought they were saying this was their answer to generic programming, but
it appears this is not the case. In any case, it was just an example of my
general feeling that the type system is more dynamic than I prefer for systems
languages.

------
markerdmann
In case you're wondering why we need another programming language, this short
audio clip from Brendan Eich is great:

<http://www.aminutewithbrendan.com/pages/20101206>

"With Rust, what Graydon has been trying to do is focus on safety and also on
you could say concurrency -- the actor model which I've spoken about recently
- and the two are related in subtle ways."

~~~
pfraze
What's the target platform? Looks like it compiles to system-executable, but
Mozilla was involved, which makes me wonder if there's browser execution.

~~~
pavlov
It's basically a planned replacement for C++ as the language used to program
the Mozilla apps themselves (and native add-ons). It wouldn't make sense as a
scripting language that runs on Mozilla.

~~~
marshray
On the audio it sounded like he went out of his way to deny that Mozilla has
any plans to rewrite existing C++.

It may be that Rust is being designed _as if_ that were a goal, but let's not
start any rumors here.

~~~
pjscott
The stated goal is to use Rust for prototypes of new browser architectures.

------
kibwen
If anyone decides to give Rust a spin and is compelled to help out by
providing feedback, the devs love to hear comments and criticism from users of
the language:

<https://mail.mozilla.org/listinfo/rust-dev>

~~~
Chirono
Do you know if there is any explanation of 'unique pointers' and 'unique
closures' anywhere? I'm quite interested to see some of the decisions,
especially wrt the type-system.

~~~
richdougherty
Unique types are used to guarantee that only a single reference is ever held
to a value. Sort of like the value has a single "owner". This restriction,
while a maybe bit of a pain to program with, gives the compiler permission to
do clever things.

In particular:

1\. The compiler can detect when a value is no longer "owned" (referenced) by
anything and free it automatically -- without garbage collection. That's
really handy for things like closures where the compiler automatically
allocated the memory for you in the first place.

2\. If an immutable value is modified then a copy usually needs to be made.
But if the immutable value is uniquely-referenced then the compiler can reuse
the old bit of memory, thereby saving a copy operation. It can do this because
it can prove the old memory can no longer be accessed.

3\. I think Rust might also use uniqueness when sending values between its
tasks. Since it can prove the value will no longer be referenced by the old
task the compiler can avoid copying the values while still preserving
isolation.

<http://en.wikipedia.org/wiki/Uniqueness_type>

~~~
Chirono
Thanks, uniqueness typing has been a bit of a hobby of mine for a few years,
so I'm familiar with 1 & 2\. Uniqueness in system-level languages, however, is
not something I know so much about, so something like 3 is pretty interesting.

------
kristianp
Original HN thread here: <http://news.ycombinator.com/item?id=3491557>

https and http links should be treated the same for de-duplication purposes,
although this thread has a few more links, and points.

------
dain
If anyone from Mozilla reads this, \- <http://github.com/mozilla/rust/issues>.

Is an invalid URL. You put the period inside the last </a>. You should toss
that out :)

------
supersillyus
Does anyone have a link to some examples of non-trivial Rust programs? It
looks like a pretty neat language (despite making a few more distinctions than
I tend to care about), but I'd like to see how it reads in practice.

~~~
mbrubeck
Here's a discussion of a ray tracer written in Rust:

[https://mail.mozilla.org/pipermail/rust-
dev/2011-December/00...](https://mail.mozilla.org/pipermail/rust-
dev/2011-December/001070.html)

and here's the source code on GitHub:

<https://github.com/brson/rustray>

~~~
marshray
I liked the part about 'immutable by default'.

I would love to have that in a language (as long as the 'mutable' keyword was
something shorter :-).

~~~
masklinn
> as long as the 'mutable' keyword was something shorter :-

That's one thing I really like, actually: use of mutable structures should be
avoided, making mutable structures harder to use (because they require a
pretty long extra keyword) is a good way to drive developers towards immutable
equivalents. See it as shifting incentives.

~~~
marshray
OK, but the goal isn't to be Haskell here, or even ML. Those languages have
all kinds of support for making immutable-everywhere a feasible goal (and the
vast majority of developers still don't use them).

If you want the language to be actually liked by people who develop large
systems, it must be designed with its users in mind. 'Nanny' languages tend
not to be very popular.

In C++ "reinterpret_cast" is a good example of something that is long and ugly
for a reason. But it's also be _very_ rare, probably an order of magnitude or
two more rare than _mutable_ in Rust (just a guess).

~~~
masklinn
> OK, but the goal isn't to be Haskell here, or even ML.

So what?

> If you want the language to be actually liked by people who develop large
> systems, it must be designed with its users in mind.

Which does not prevent the language from driving users towards a goal. One of
Rust's goal is emphasizing immutable structures, that's #8 on the front page
of its website:

> immutable by default, mutability is the special case

mutability is the special case and a special case Rust tries to make people
_avoid_.

> In C++ "reinterpret_cast" is a good example of something that is long and
> ugly for a reason. But it's also be very rare

And so ought mutable structures be in Rust.

------
InclinedPlane
Maybe I'm crazy but it seems like a lot of these recent new languages are
missing the mark. If you're designing a language from the ground up why
wouldn't you build unit testing as a first class citizen, for example? As well
as profilling and instrumentation. How about a modular compiler that can
round-trip back and forth between raw source and commented parse trees so you
can do much smarter merging in source control?

So many languages seem to be aiming at targets that are pretty far away from
the major pain points for the normal developer.

~~~
pcwalton
Unit testing is a first-class citizen in Rust. You can annotate functions with
#[test] and they become unit tests. You can then run tests with the built-in
test harness on a module-by-module basis.

Profiling and instrumentation are possible using the standard tools (xperf,
Instruments/DTrace, perf/oprofile). Rust works just fine with those.

Not sure what you mean by "round-trip back and forth between compiled code and
commented parse trees", but Rust contains a pretty-printer which preserves
comments.

~~~
nwmcsween
Can you clarify a few things, these are bikeshed issues but they bother me
none the less.

* Why was fn foo(bar: int) -> int chosen and not fn foo(bar:int): int? * Why annotations within comments? Annotations aren't comments it smells of C bolt-on. Why not keyword annotations?

~~~
mhitza
Because with the arrow syntax for results it makes it cleaner for functions
that return functions?

fn (x:int) -> fn@(y:int, z:int) -> int

~~~
fzzzy
Also passing functions to functions:

fn foo(bar: fn(baz: int) -> int) -> int

Instead of

fn foo(bar: fn(baz: int) : int) : int

------
swah
Implementation partially in OCaml! (But why don't we use Ocaml again?)

~~~
jamii
> But why don't we use Ocaml again?

Rust offers better control over memory layout, more predictable resource usage
and a fuller concurrency model. If it works out it will be a good replacement
for ocaml, especially for systems development.

~~~
pjscott
Also, the syntax of Rust is less frightening for people who don't know Ocaml.

------
nixarn
They need to learn from Google how to present a new language. Although maybe
they will once it reaches 1.0. When Google showed off Go they had some really
great examples and a clean web page for it. Got me excited, this hasn't.

Edit: Apparently there is <http://www.rust-lang.org/>

~~~
stewbrew
"They need to learn from Google how to present a new language"

You mean like choosing a name that is easy to search on the internet?

------
mapleoin
I find it really interesting that Rust itself requires all these languages to
compile:

    
    
        g++ 4.4 or clang++ 3.x
        python 2.6 or later
        perl 5.0 or later
    

Does anyone know why that is?

~~~
fzzzy
The perl dependency is from LLVM. Rust uses Python for utility scripts, "Just
Because."

Also, you left rustc off the list of languages required to compile rust. :-)
It's self-hosted.

------
protomyth
Is there a reference manual anywhere?

~~~
capnrefsmmat
There's a language reference and a tutorial:

<http://doc.rust-lang.org/doc/rust.html>

<http://doc.rust-lang.org/doc/tutorial.html>

------
jon6
The language looks ok. If they are going for world domination a more likely
path seems to be evolving C very slowly. That is they should start from C and
then every few years add a few new features and take out some old crummy
features until they finally reach Rust.

Lots of people probably don't like rewriting code bases wholesale and new
languages take a while to become trusted.

~~~
aaronblohowiak
> and take out some old crummy features

Backwards-compatibility is held extremely dear to the C community, with those
few breaking changes being simple (usually) to work around. If you want to
break compatibility, you have a better chance calling it a new language.

~~~
jon6
Thats true, but new modes can be added with switches similar to how gcc has
-std=c89, -std=c99 and whatnot. Newer modes could disable old features and
people could upgrade at will.

~~~
rcfox
Except that there's no business case for rewriting old code that still works
and is still supported by the compiler. And then suddenly, the compiler team
has to support multiple, very different versions in the same release.

------
rmoriz
If you reinvent the wheel you should at least have one plausible use case that
shows the benefit of your square/wheel over existing solutions.

Bonus points for real world examples.

~~~
samth
Imagine Firefox, but without segfaults, and using multiple cores.

That's the use case. Rust is intended as a safe language for building a
research browser that works in parallel.

------
markwong
And we have Ada.

~~~
mulander
Honestly, I am observing closely the way some new system languages evolve - D,
Go, Rust and I see a large intersection of features with Ada.

I am always amazed that no valid discussion/comparison of those languages and
Ada erupt in these threads :( Ada is not as bad as it's painted to be.

~~~
markwong
i find Ada is a good and consistent programming language.

