Rust 0.6 Released

https://mail.mozilla.org/pipermail/rust-dev/2013-April/003427.html

by metajack • 13 years ago

186 115 13 years ago

mail.mozilla.org

pjmlp8• 13 years ago

Great!

Time to upgrade.

Just as a side note, I am looking forward to the day I won't need to recompile LLVM as well.

film42• 13 years ago

Call me a noob, but I have never been properly introduced to Rust. Does anyone know of a good article or walk through with pros, cons, and examples?

metajack• 13 years ago

This is the best talk I've seen on Rust so far.

http://www.infoq.com/presentations/Rust

The tutorial is also pretty good (as are the supplemental tutorials), but they don't yet give you the full picture. For that you'll have to play and experiment and read some code.

You might start here for some code to read:

https://github.com/pcwalton/sprocketnes

kibwen2• 13 years ago

The language is still changing so fast that nearly every resource that you'll find will be outdated. Your best bet is likely the official tutorial,[1] which probably doesn't contain too many references to deprecated features.

[1] http://static.rust-lang.org/doc/tutorial.html

ineedtosleep• 13 years ago

What parts of the language have been changing? And maybe to reduce the scope of that question a bit: are there any specific features that need to be solidified first before someone should bother learning Rust?

steveklabnik10• 13 years ago

I wrote a 'book' (it's about 50 pages) you can read online called "Rust for Rubyists".

Two things: It's for 0.5 (I'll be updating it to 0.6 later today/tomorrow) and 'for Rubyists' means I assume you don't know anything about systems programming, there's very little that's Ruby-specific.

http://www.rustforrubyists.com/

abraininavat6• 13 years ago

'for Rubyists' means I assume you don't know anything about systems programming, there's very little that's Ruby-specific.

Then put out the same book with a new title, "Rust for Pythonistas". Two books for the price of one!

drbawb4• 13 years ago

This isn't a tutorial, but I found pcwalton's explanation of memory management in rust[0] to be an excellent primer for the different allocation techniques in rust.

Learning the different types of pointers was a real pain point for me; so I'm very thankful for this post. Maybe it will help you out while you're learning!

[0] http://pcwalton.github.com/blog/2013/03/18/an-overview-of-me...

kibwen2• 13 years ago

Anyone who found that post illuminating may also enjoy this general "Rust for C++ programmers" reference: https://github.com/mozilla/rust/wiki/Rust-for-CXX-programmer...

ksec• 13 years ago

Slightly Off Topic: Wasn't Rust suppose to be the codename or working name of the languages. Or Has Mozilla decide to simply use Rust as its official name?

icambron• 13 years ago

I don't know the answer to that, but the problem may be that Rust is decent enough name to overcome any proposed name changes. I've always thought you should use implausible codenames for just this reason. It forces you to change it instead of just letting the codename establish itself by momentum. I've always assumed that's why Microsoft uses terrible codenames like "Longhorn".

chimeracoder• 13 years ago

When developing Java, Sun figured out a way around this.... which is how we ended up with the name Swing: https://blogs.oracle.com/thejavatutorials/entry/why_is_swing...

ovis• 13 years ago

That must have backfired for the Fedora folks.

nnethercote• 13 years ago

I'm pretty sure Graydon always intended Rust to be the final name.

coldtea6• 13 years ago

Never heard something about it being just a codename. Why would it be? Rust is quite nice itself and has already 1-2 years of being established.

It even makes sense as an faux-etymology.

Rust: because it's close to the metal and brings some breathing oxygen to the stale system's language arena...

shared4you• 13 years ago

Previous discussion just 3 days back: https://news.ycombinator.com/item?id=5468896

[This was for RC though]

wrl• 13 years ago

`Static methods no longer require the `static` keyword and instead are distinguished by the lack of a `self` parameter`

Man, am I the only one who really doesn't like implicit things like this?

efuquen• 13 years ago

Well, it does kind of make sense. If you never access anything from self then for all intent and purposes there is no reason the function shouldn't be static. That's just my initial perspective reading your comment, not knowing much about the language, so I might be missing some possible scenario this would actually result in a runtime error.

jeremyjh• 13 years ago

Actually I think its much more explicit that self is ALWAYS passed as a parameter, or it doesn't exist.

pcwalton4• 13 years ago

This change improves consistency between implementations and modules. `impl MyType { … }` is now just like `mod my_module { … }`, except that you can define methods inside `impl` declarations by including a self parameter.

For example:

    struct MyType { … }
    impl MyType { pub fn foo() { … } }
    mod my_module { pub fn foo() { … } }
    fn main() {
        MyType::foo(); // works
        my_module::foo(); // works too
    }

kzrdude• 13 years ago

Your comment is funny since the other part of the change you cited is the introduction of explicit self.

charlescearl2• 13 years ago

Just glanced at the discussion on LtU http://lambda-the-ultimate.org/node/4009, I wonder if the C++ hackers have swallowed, and if they are hearding them onto Haskell?

steveklabnik10• 13 years ago

That discussion is very old.

charlescearl2• 13 years ago

Quite, but I generally use as a way to gauge "language innovation" relevance. It looks like the lag time on getting into innovative programming principles into production languages is ~5 years. The discussion is quite interesting in laying out some of the practical issues with introducing PL research concepts into code that must support large products and large developer bases.

terhechte3• 13 years ago

It is interesting how many of these newer languages clearly try to improve upon a specific older, established language (at least imho) (take with a grain of salt).

C++ -> Rust

C -> Go

Java -> Scala

Lisp -> Closure

Erlang -> (Go or Scala)

Javascript -> (Too Many; Dart, et al)

(Edit: Formatting)

Kototama2• 13 years ago

It's Clojure, not Closure. Google Closure is an optimizing JavaScript to JavaScript compiler.

I'm not sure Go try to replace C. Most (all?) embedded systems need to control memory allocations.

jff• 13 years ago

Where does C imply embedded only? The Go authors spent years writing non-embedded programs and operating systems in C, after Ken Thompson laid the groundwork to create C.

pjmlp8• 13 years ago

> I'm not sure Go try to replace C. Most (all?) embedded systems need to control memory allocations.

Are you aware that there are embedded systems coded in GC enabled languages?

It is all a matter of the available resources.

mtgx• 13 years ago

Could we see a brand-new Chrome browser written in Go, though? Or would it better for Google to use Rust, too, for that?

terhechte3• 13 years ago

Sorry, typo regarding Clojure. Can't edit it anymore though :(

kenko• 13 years ago

Go or Scala attempt to improve on Erlang? Elixir attempts to improve on Erlang---that I can see.

old-gregg• 13 years ago

As much as I like Golang, it is not a replacement for C. The major reason C is so popular because it's the only portable medium for performant code which can be shared across many languages because it doesn't impose any runtime on you.

Go comes with a VM. It lives in its own world, it cannot live in the worlds of other VMs like C can. It's more like high-performance Python (or simpler+slower C++) optimized for concurrent network services.

I'd say that Rust and probably D are good candidates for replacing C.

steveklabnik10• 13 years ago

Currently, Rust cannot go without its runtime either. The plan is that it eventually will be able to.

(EDIT: VM -> runtime)

mindslight• 13 years ago

The greatest trick libc ever pulled was convincing the world it didn't exist.

abraininavat6• 13 years ago

I agree. People mistake the fact "Some C people really like Go, for some of the same reasons they like C" for the falsehood "Go is a good candidate to replace C in the domains C it typically best for".

kisielk• 13 years ago

Go doesn't come with a VM, it comes with a runtime. Go code compiles to native machine code.

pjmlp8• 13 years ago

The only language that does not have a runtime is called Assembly.

And even in the case of CISC processors there might be microcode playing the role of a runtime.

Why don't people learn about compiler design nowadays?!

dsego• 13 years ago

Vala?

steveklabnik10• 13 years ago

To be fair, with Rust it's more like

    C++ -----
             \
    OCaml ------> Rust
             /
    Erlang --

gcr4• 13 years ago

What does the language family tree look like with Go at the root?

masklinn3• 13 years ago

> C -> Go

Most of C's use cases, Go can't even remotely be used for. It's basically limited to the "network server" use case. It's not portable, it's not a linga franca (via FFI for non-C languages), it's not low-overhead, it's not runtime-less, ...

> Erlang -> (Go or Scala)

Yeah... no, especially not Go. In Erlang's inception, concurrency was first and foremost a tool for reliability (from its telecom roots where 1 = 0, so 1 server means the same as not having a server). Just about none of Erlang's reliability mechanisms are present in Go.

burntsushi4• 13 years ago

> It's basically limited to the "network server" use case.

I've been using it to perform research. I also used it to build an X window manager. Neither are remotely close to a "network server" use case. In years past, I would have used C for both projects.

> Just about none of Erlang's reliability mechanisms are present in Go.

I certainly agree that Go shouldn't be viewed as a "better" Erlang, but Go does have green threads with M:N scheduling, which is a significant feature of Erlang. (As argued by Joe Armstrong himself.)

rdtsc• 13 years ago

As someone already mentioned, -1 on Erlang-> (Go or Scala)

They didn't try to improve they removed features such as error handling, distribution, all which are very important for building fault tolerant system.

Paradoxically perhaps, I see it inverted:

(Go + Scala) -> Erlang

Temporal sequencing doesn't necessarily imply strict improvement.

terhechte3• 13 years ago

I was referring to how Scala copied the actor model (though it is was not invented for Erlang either) and several other Erlang-ideas while adding new features and running on the JVM. In some direction similar with Go; You're right though, it wasn't the best of comparisons.

pjscott• 13 years ago

That's definitely not a new trend.

http://www.paulgraham.com/fix.html

epsylon2• 13 years ago

> Lisp -> Closure

There is no single "Lisp", but many dialects including Common Lisp, Scheme (and its bazillion variants), Clojure, Emacs Lisp, Arc...

> Java -> Scala

Except for the fact that Scala is based on the JVM and partly reuses the Java standard library (for interoperability reasons), the language is the product of many influences, including ML, Haskell, Java, Scheme, Eiffel... The syntax and the "feel" of the language is actually quite far from Java thanks to its functional side.

drbawb4• 13 years ago

Awesome! I'm going to compile `release-0.6` right now, because I've been having some issues w/ trunk these past few days.

Simple things like declaring fixed vectors won't compile for me: `let numbers: ~[int, ..3] = [1,2,3];` fails to compile saying it expected `~[int * 3] and got ~[<VI2>]`. That's an example straight from the tutorial.

I'm getting segfaults when iterating over a non-fixed vector of owned elements casted to a trait. (This works fine if I access the elements directly; or use managed pointers. With owned pointers my `len()` method returns the wrong number of elements, which I suspect is breaking the iterators.)

pcwalton4• 13 years ago

The tutorial examples are run as part of the test suite. The tutorial example in question is `let numbers: [int, ..3] = [1, 2, 3];`, which should work.

There are several known compiler bugs with any trait types other than `@Trait`. Please do continue to file any bugs you find, though—all crash bugs are bugs that need to be fixed :)

drbawb4• 13 years ago

Whoops, I did botch up the syntax on my listed example.

I compiled release-0.6; and sure enough `let numbers: [int, ..3] = [1,2,3];` compiles.

`let numbers: ~[int, ..3] = ~[1,2,3];` does not compile on my system though. Ditto for the @ sigil.

(Expected `~[int * 3] but found ~[<VI2>]`)

My understanding is that the first example [from the docs] allocates the vector on the stack.

My uncompilable examples should be equivalent except that they use the heap for storage.

Is there a reason this shouldn't compile?

Thanks so much for the reply!

steveklabnik10• 13 years ago

From the release notes[1]:

    > While we cannot promise that this is the last time there will be incompatible
    > changes, the great majority of anticipated language-level changes are
    > complete in this version

I'm quite excited about this.

1: https://github.com/mozilla/rust/wiki/Doc-detailed-release-no...

PommeDeTerre• 13 years ago

The most exciting thing about Rust is that we keep seeing something that's already pretty good continually getting better and better.

This is much different than what we're seeing with the evolution of, say, JavaScript or PHP. There, the languages are pretty horrific to begin with. Any "improvements" tend to be yet another hack layered upon one or more earlier hacks. Even in the best cases, these "improvements" are merely bringing JavaScript and PHP to where many other languages were 10 or 20 years ago (if not going back much earlier).

I think the fact that Rust is already so coherent makes these improvements and refinements much more impressive. It's much harder, and requires more real innovation, to improve something that's already great to begin with. Yet that's exactly what we're seeing with Rust.

gcr4• 13 years ago

What "improvements" are you seeing with Javascript? The language is essentially done; all improvements I've seen come in the form of new libraries (jquery et al), environments (v8/nodejs), or revisions (jsnext, asmjs) that IE won't ever adopt.

lifthrasiir2• 13 years ago

Much more exciting thing about Rust is that it is actively moving to reduce the language features. At the version 0.1 I was literally shocked about the typestate system ("It is a good idea but I don't know how this feature will end up!") but it is now replaced by other features (owned pointers in this case) more fundamental and more easier to reason. As an wannabe language designer I understand this is very hard to undertake, and I'm appreciate all these works by Rust team and contributors. :)

mhartl• 13 years ago

Mozilla and the Rust community are pleased to announce version 0.6 of the Rust compiler and associated tools. Rust is a systems programming language with a focus on safety, performance and concurrency.

This is how you do an announcement right: you include a short description of the product along with the announcement. This way people who don't know WTF Rust is are immediately brought up to speed.

Rust 0.6 Released

Related Stories