Announcing Rust 1.6

http://blog.rust-lang.org/2016/01/21/Rust-1.6.html

by steveklabnik • 11 years ago

443 216 11 years ago

zcdziura• 11 years ago

What do you mean when stating that applications aren't supported for developing around libcore?

steveklabnik21• 11 years ago

Specifically, there are two 'weak lang items' that need to be defined. Lang items are not yet stable. So while you can build libraries with only core, the final binary still needs to be compiled with nightly.

For now.

Furthermore, you can use a no_std library with an application that uses std just fine. The use case not quite covered is "I want an application with no standard library at all, period."

JoshTriplett2• 11 years ago

Specifically, there are two 'weak lang items' that need to be defined. Lang items are not yet stable.

What two specific items? By "lang item" here, do you mean roughly "symbol", or something else entirely?

mindslight9• 11 years ago

FWIW, the stable release purposely having this functionality removed is pretty annoying. Using periodic versioned releases is much nicer than sporadic snapshots (I've avoided the issue by not mucking with STM32 stuff in a while). A flag like #![use_unstable_features] would be friendlier.

dikaiosune11• 11 years ago

May the libc event never occur again (at least, I think it was libc with the wildcard dependencies). That's great to hear.

steveklabnik21• 11 years ago

Yes, that was part of it. It was a complicated situation, from which we all learned a lot.

(For those not familiar: the libc crate went from 0.1 to 0.2. Many people were depending on libc="*". Cargo allows for multiple copies of a library with incompatible versions. But the releases were incompatible for a reason... it caused problems. This fix is one of the things we're doing to address it, there's more coming in the future.)

djb_hackernews• 11 years ago

I've poked at the language a bit over time and while I don't think I'll ever "get" rust, I can say the folks in #rust on irc.mozilla.org are friendly and helpful, which can't be said for all languages.

dman• 11 years ago

Is this you - https://en.wikipedia.org/wiki/Daniel_J._Bernstein ?

lambda• 11 years ago

From the comment history, I don't think they are the same djb.

nickpsecurity12• 11 years ago

Best not to even ask such a question as it invites dishonesty. Just look up the contact information and compare. Here's DJB's:

http://cr.yp.to/contact.html

nickpsecurity12• 11 years ago

The docs stomped me, too. I sent suggestions for metaphors and such that might help confused people. They're hard at work on the issues from what I've seen, though. So don't give up yet: check back in a year or so to see if revisions bring you extra clarity. :)

VeilEm3• 11 years ago

Congratulations! I'm loving Rust, it's my go-to default language now. I'm going to start messing around with piston.rs to make some basic 2d games. I already wrote an irc bot with Rust.

For those wondering, stable just meant the API defined for interactions with some libraries were subject to change. It wasn't like a problem with using the APIs, it was just the developer has to know that new releases might change how they worked or if they would even be available in the future.

chocolatebunny• 11 years ago

How are the software libraries for Rust? What did you do for network access, string manipulation and GUI stuff?

VeilEm3• 11 years ago

The string manipulation is good in Rust, but in Rust strings are unicode and characters are unicode codepoints. IRC is an ASCII protocol and so I went with using binary slices `[u8]` for parsing.

For network stuff I used openssl[0] and std::TcpStream [1]

I didn't use a GUI. I plan on using piston.rs[2] to build games but there are Qt, GTK+ and even Cocoa integrations for rust.

[0] https://crates.io/crates/openssl/

[1] https://doc.rust-lang.org/std/net/struct.TcpStream.html

[2] http://www.piston.rs/

rjtobin• 11 years ago

There are wrappers for basically any C/C++ library you can think of. I found string support to be pretty great from the standard library (compared to C++), such as UTF-8 and string interpolation.

In terms of networking, I threw together a working console IRC client in about 60 lines of Rust (using standard library threads and TcpStreams). And I'm very much a Rust beginner. And Rust forced me to consider error handling in a way I wouldn't have otherwise.

I should also say that the community is unusually supportive: I've asked some questions on the IRC channel and got really helpful replies (and haven't noticed any of the snark that comes with a lot of IRC channels).

anonbanker2• 11 years ago

from the #gimp IRC Jargon file:

irc client: Everyone's least favorite Gtk project. For whatever reason, at one time there were seven active projects to develop a Gtk irc client. Used to deride poor judgement in choosing projects or lack of knowledge about what's going on. Often used self-deprecatingly, as in "I know, I'll write an irc client."

Thanks for keeping the dream alive.

VeilEm3• 11 years ago

I made an irc bot, not an irc client.

An IRC bot is a great way to learn a new programming language. You have to learn how to use threading or asynchronous operations to get multiple connections, you have to learn how to use TLS for secure connections, you have to learn how to manipulate strings, how to read configuration files. It's a super good project for learning.

Cshelton3• 11 years ago

This is relevant and cool, UPenn now has a course for Rust - http://cis198-2016s.github.io/

You can follow along, all slides and HW are on github.

blakesterz• 11 years ago

That setup is great, that's all on github? Is there a How-To around that I could follow to put something like that together?

astockwell• 11 years ago

https://pages.github.com/

They probably should have prepended the school name to their GitHub org, but that's just my 2 cents :)

it_learnses2• 11 years ago

Why does the first page for the intro lecture slides say Intro to Cobol and then two pages later, Intro to Rust? Are they trying to troll?

dikaiosune11• 11 years ago

Not all jokes are trolls.

nickpsecurity12• 11 years ago

Maybe to illustrate the difference between programming for pay and programming for fun that many students might eventually experience. They use an extreme example to scare away those who aren't committed enough. ;)

lgessler• 11 years ago

See also UVa's Spring 2014 OS course, which was taught in Rust: http://rust-class.org/

dikaiosune11• 11 years ago

Is Rust from spring 2014 remotely compatible with current Rust (since 1.0--and the stability commitments--were in May 15)?

lasermike026• 11 years ago

Very exciting!

EugeneOZ4• 11 years ago

Keep going! Thanks to all contributors for their work on this awesome language and crates.

I use Rust for web as REST API and I'm absolutely in love with this language. Maybe first steps were little bit steep, but it's worth it :)

// cargo run!

smt88• 11 years ago

Would you be kind enough to list the crates that your API is using?

EugeneOZ4• 11 years ago

Of course. Special thanks to their authors ;)

  [dependencies.iron]
  version = "0.2.*"
  
  [dependencies.bodyparser]
  git = "https://github.com/iron/body-parser.git"
  
  [dependencies.redis]
  git = "https://github.com/mitsuhiko/redis-rs.git"
  
  [dependencies]
  router = "*"
  rustc-serialize = "*"
  plugin = "*"
  rand = "*"
  toml = "*"
  rust-crypto = "^0.2"
  hyper = "*"
  r2fa = "*"
  urlencoded = "*"
  regex = "*"
  
  [dependencies.mysql]
  default-features = false
  features = ["socket"]

And soon here will be added "rusoto".

Keats2• 11 years ago

Hoping for a write-up if you have time!

EugeneOZ4• 11 years ago

Going to write it after January 27 - it's date of launch second web app, which will work in production, powered by this API.

valarauca17• 11 years ago

Actually managed to sneak some Rust into production. Nobody cares what language you wrote the DLL in, just that it does what the docs say it should do.

eterm• 11 years ago

Said no one who has to maintain others' software.

humanrebar• 11 years ago

It's a fair point, but there's a lot of write-only Perl, PHP, and C out there. Let's make sure we don't hold new Rust code to a higher standard that that stuff.

jeffdavis• 11 years ago

He said it's documented. That tells me it's probably easier to maintain than many other approaches.

blantonl• 11 years ago

This is where grey-bearded consultants make their bank....

erickt• 11 years ago

Wonderful! Are you able to say which company you deployed this in, and if you've run into any trouble? And by DLL, was this in Windows? I can't recall if we've heard of any Windows users putting rust into production yet. We're quite interested in making sure our production users don't run into any problems. If you'd prefer to not speak in public, you could reach out to our private channel, community-team@rust-lang.org. Best of luck!

nickpsecurity12• 11 years ago

"Are you able to say which company you deployed this in?"

"Actually managed to sneak some Rust into production."

"...sneak some Rust..."

"...sneak..."

There's your answer on that one. ;) Others might be quite useful, though.

haberman2• 11 years ago

Since this release is focused on stabilizing libcore for embedded use, it seems a good time to ask a question that's been on my mind.

C11 (and C++11) defined a memory model and atomic operations for shared-state lock-free concurrency. But that model and the atomic operations aren't being used by Linux, because they didn't match up with the semantics of the operations that Linux uses. (See https://lwn.net/Articles/586838/ and http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p012...).

I'm curious what Rust says about this. Does Rust have a memory model like C11/C++11? I'm curious whether Rust (and C11/C++11 for that matter) will evolve to have primitives like what the Linux kernel currently defines and uses.

steveklabnik21• 11 years ago

We do not have a formal spec yet, and so do not technically have a memory model like C or C++ do. However, since we're built on LLVM, we do have some semantics that are pretty much based on it. Our atomics stuff is pretty much LLVM's. A lot of the work going into forming said models is trying to determine how much of LLVM we've let pollute into the language in the meantime and where it's feasible to diverge.

https://github.com/rust-lang/rfcs/issues/1447 is a good thread if you care about this topic.

johnbender• 11 years ago

http://plv.mpi-sws.org/rustbelt/

As part of defining the Rust semantics they will certainly tackle the question of the memory model. Dreyer and company have a track record of providing semantics and reasoning principles for weak memory models (like C11).

You might have to wait a while for a rigorous semantics though.

hellofunk3• 11 years ago

I'm curious if what you mean is that C++11 has a standard spec for the memory model you describe, but if Linux doesn't use it, then Linux does not actually adhere to the C++11 standard? Does that mean that Linux C++11 compilers are non-standard in general?

Manishearth8• 11 years ago

I don't think there are any (modern) C++ compilers out there which follow the standard 100% and perfectly. ICBW.

haberman2• 11 years ago

Let me clarify first that when I say "Linux" in this post, I'm specifically referring to the Linux kernel, not user-space software that runs on Linux.

The Linux kernel is written in C, but uses lots of GCC-specific features and inline assembly to address things that aren't covered by the C standard. Among these, the Linux kernel has its own set of atomic types and memory barriers. It documents them here: https://www.kernel.org/doc/Documentation/memory-barriers.txt

So even if Linux is being compiled on a conforming C11 compiler (the Linux kernel is written in C, not C++), it uses its own atomic primitives instead of the ones provided by the language. Hope that helps.

criddell• 11 years ago

I have a question for Rust fans: how do you deal user interaction? Do you have a favorite user interface library? Do you separate the UI from the program and communicate either via IPC or http+html? If you don't care about cross platform capabilities, is there a great library on the platform you do care about?

nikolay4• 11 years ago

I think Rust badly needs an AWS SDK as a lot of systems software is being written now in Go...

EugeneOZ4• 11 years ago

Something like this? https://github.com/rusoto/rusoto

nikolay4• 11 years ago

That has around 5% of the full AWS SDK coverage...

dikaiosune11• 11 years ago

Like this?

https://crates.io/crates/rusoto/

Haven't tried it yet (backwaters don't usually look kindly on AWS :) ), but that looks like what you're talking about. There are a ton of libraries for Rust these days (relative to the amount of time since 1.0, at least).

hrez• 11 years ago

Yes, except with ec2 and tons of other missing AWS services support.

allan_s3• 11 years ago

I was wondering:

As the HN crowd seems to have quite a lot of Rust supporters, would it be a good selling point in a job description ?

i.e if (it's just currently a personal hypothesis) a company were to consider to (re)write some part of its Rest-ish microservices and that Rust was the chosen language, and was looking for people to help on that, would it make a `interesting++` in your mind ? for real services used by real people by a not-so-startup company, in europe.

edit: I already deployed in production for my previous company some (with a very stricly limited scope) microservices in rust (with everyone approval) and it was quite a success, so I'm more and more thinking that rust is now enough developed to fit the market of language for microservices, as it's more or less "understand HTTP, read/write from redis/postgresql/mysql/memcache, do some transformation in between" and Rust now support these operations quite well

dikaiosune11• 11 years ago

A friend of mine asked me about this last weekend, and I basically said that I've drunk enough kool-aid at this point to do anything to use it as my main work language. I'm lucky enough right now to have a lot of autonomy for my projects, and I'm using that to build some tools in Rust, but it's different than being able to focus on it full time.

seivan• 11 years ago

I know the feeling. I'd sacrifice my own free time to fill the gaps I know it's missing from Rails, it's only fair as I would operate 10x faster with things I'm comfortable with and has a full set toolbox. Considering Rust but, would prefer Swift or Typescript.

azdle• 11 years ago

It would be for me, but like dikaiosune I've drunk the Rust koolaid almost fully by now.

But honestly, even if I hadn't it's be a selling point to me because it tells me that you're a place that isn't stuck writing everything in a single language but are willing to try new things are willing to use what seems to be the right tool for the job.

kbenson5• 11 years ago

Well, sometimes depending on company size, number of developer developers, developer pool skill set, and many other factors, having a single (or very few) languages is a factor in the right tool. It's better when that's not the case though.

CuriousSkeptic• 11 years ago

It just seems like an odd use case for rust. I can see how it would be attractive as an alternative to c++ or other systems language. But for shuffling data?

Also, since you mentioned PostgreSQL, if you can make the db handle json the shuffling part should be really trivial. Give node.js + pg-promise a spin for comparison.

But then again, I haven't used Rust for anything serious, so am happy to be wrong.

dikaiosune11• 11 years ago

I've always liked the idea of using "systems" languages for data shuffling, because of the ability in some cases to stretch hardware several orders of magnitude further. I read this a while ago and just dug it up:

http://stevehanov.ca/blog/index.php?id=95

It's a bit silly, but I do think that Rust could be a very good solution here. For one thing, in my experience it is much easier to write than C++, especially for something you'd feel comfortable pointing at users.

It would be cool to see some articles that are the reverse of "scale all the things," something like "sympathize with all the caches."

allan_s3• 11 years ago

Rust made sense for me for that case because:

1. rust handle erros in a VERY expressive way, and I do want my services to log ANY errors, and to be sure to miss any (kind of like what go permits too , but Rust Errors are more flexible) , so with rust it's hard to forgot a case of error and finished with "errr my API did a 500 but i don't know why"

2. It's a (nearly) self contained binary with low memory overhead, I can have dozen of microservices like this on my workstation / CI environments without making the machine cries So I can deploy it on cloud provider X or workstation Y without needing to worry if it has the version of node / python / php I need

3. it creates very small docker image if you're using docker (so it beats node/python/php here)

4. if I want to make my services multi-threaded and have some internal cache for some reason I'm sure the compiler will not let me create concurrent access problem that I would otherwise only detect in production when it's too late (beats every other languages , including go , the go race detector of go is nice, but it's at runtime so not the same league)

5. no nil pointer exception things (beat other languages here too)

6. strong typing but flexible (no go, I don't want to cast everything in {}interface everytime i need to make things a bit more generic, though I know it's just a personnal opinion), because no I don't want my developer to either develop a "is_true" function , or worst to rely on type casting for if to work.

7. the compiler as my first set of test it's a whole category of things you don't need to write test for because it's already handled by the compiler.

8. highlevel when you needs, low level when you want, I know that the language is not my bottleneck (or then I've reached the point where I don't care because my system is performant enough) , but if I need to serialize my struct into a json, I can in some line of codes.

9. plenty other little things , like scoping variables, immutable by default , possibility to have your SQL request check at compile time if you use postgresql plugin, using first-class debuggers to do step by step if you need , interfacing with C libraries pretty easily

Matthias247• 11 years ago

I agree here. I'm often attracted to new stuff, so working with something new (like Rust) would be a plus in a job description, but I also think is the wrong tool for this kind of task - which would yield a minus for the job description.

This is the classic domain of scripting languages (PHP, Ruby, node, ...), where a huge ecosystem exactly for this kind of tasks exists. But yes, type safety and error handling is not the best there.

If a good type system and a good ecosytem is desired then F# or a JVM language (Scala with Play Framework, Kotlin, ...) could be used, which would from my perspective give a more productive setup for this task.

I don't want to say that Rust is not good, but (just like C++) I think it's best use cases are other applications then webservers, e.g. high performance audio and video processing or bare metal software.

peteretep• 11 years ago

I'm a recruiter (and a developer).

Yes it would. People love to be trained on a new software stack at someone else's expense, especially if they're not having to take a seniority hit to go there.

Thaxll• 11 years ago

I don't understand why would you choose Rust over Go for backend stuff. From what I see here on HN, Rust doesn't target backend app?

eru2• 11 years ago

Rust is a nicer language than Go---especially its type system. That might be reason enough.

What do you mean by `doesn't target backend app'?

echelon2• 11 years ago

I've already written several components of my home automation system in Rust. Mio, Hyper, Iron, etc. are great tools for developing microservices.

I cross-compiled this stuff to run on Raspberry Pi, and the binaries are so small and performant!

paulddraper• 11 years ago

Because he doesn't enjoy casting every time he iterates over a collection?

Because he doesn't like NULL pointers aka the worst mistake of CS?https://www.lucidchart.com/techblog/2015/08/31/the-worst-mis...

Because he doesn't want a package manager that always fetches HEAD?

I'm not saying Go is a poorly designed language where the answer to every decision is the easiest one for the implementors. I'm just saying there's a legitimate case to be made.

Manishearth8• 11 years ago

Rust doesn't target backend app?

This isn't the case. We have web backend libraries (servers, database thingies, template engines, I/O, etc) and it's totally possible to work on backend stuff in Rust. Rust doesn't "not target" much, really. Most of what you do in Python/Go/Ruby is also something we want Rust to work for. There is a false dichotomy of "fast language or safe language" which Rust does away with -- it's not only for situations where you would usually use C++.

allan_s3• 11 years ago

I've posted reasons why here : https://news.ycombinator.com/item?id=10949667

more reasons:

On error handling, in Go most of libraries and even some part of the std lib, erros are constant string, which mean that for example you can only do

`err == foo.DUPLICATE_KEY_ERROR`

but you can't extract which key, or then you start to have to either use an external library to do some string masking/unmasking, which complicate quite things and add one more dependency, or just to say "screw it, i will just log 'duplicate key error" which is unoptimal

I really did try go, to the point I even proposed a fix in the std library for a long standing bug in the xml library https://go-review.googlesource.com/#/c/15684/ , but not all the reason stated above makes me consider go as "yes sure it's an improvement over php/python/c++" but rust is like an even bigger improvement

vitno• 11 years ago

yes. I would do pretty much anything to work in Rust at this point.

shepmaster• 11 years ago

Absolutely. And if you hire remote, I'd be happy to apply!

lmm2• 11 years ago

If I couldn't find a job writing Scala or OCaml or F# (all of which I'd consider better options for rest-ish backends) then I'd look for one writing Rust.

As I got more into this kind of language I found that the language tools gave me very strict isolation, which lowered the value of separating everything at the process level. So I've shifted towards a more monolithic style of architecture.

wyldfire2• 11 years ago

W00t, I made the contributor list!

steveklabnik21• 11 years ago

Thank you for your contribution!

wyldfire2• 11 years ago

lol it was a paragraph or so of a doc revision. But I'll take it. :)

sdegutis• 11 years ago

After trying to understand some Rust, it seems to me that it's just as complicated as C++, from the programmer's perspective. Was I mistaken in thinking that being simpler to program in than C++ was one of the goals?

dikaiosune11• 11 years ago

When I've dabbled in C++ in the past, worrying about safety (does my custom trie implementation segfault? is this iterator still valid? can I trust the code I just vendored into my repo?) was the main source of complexity, both in initial writing of my code and in debugging it. Working in Rust has been a comparative (and simple) delight for me.

steveklabnik21• 11 years ago

We have a number of similar features, but ours are generally more straightforward since we didn't have to worry about backwards compatibility. We also have some features that C++ does not, and they have some we do not.

echelon2• 11 years ago

I don't use C++ or Rust in a daily context, but I can say without a doubt that Rust is the easier language to grasp. I don't have to decide anything about headers, linking, Makefiles, etc. to get things up and running; I can declare dependencies in Cargo.toml and it just works.

The Rust standard library feels so much more modern and easy to use than the STL. The documentation is fantastic, too.

C++ pointers, casting, OO, templates, and all the billion other language features feel like traversing down a rabbit hole. Rust is small enough to grok in a day. The syntax is incredibly expressive and a joy to use.

bjz_2• 11 years ago

Rust is small enough to grok in a day

I would say it is far easier to learn how to write good systems code in Rust than C++, but saying you can grok it in a day is a bit optimistic. On the surface level, perhaps. But the semantics of the type system can take longer to internalise, depending on one's background.

Manishearth8• 11 years ago

Multiple startups have wanted to or used Rust for systemsy components because their devs were mainly from dynamic language camps and they felt that in the process of learning Rust you end up learning systems programming, which is less so the case for C++.

Rust does have a lot of features, but for most programming often you don't have to dabble in the more advanced features, which is great. Whilst working on Servo I mostly stuck to the basic features which I was familiar with for a long time and only learned the complicated stuff after a few months out of interest.

One major difference is that Rust forces you to learn about ownership and borrowing up front. This is cognitive load you would have to take in any systemsy language at some point when learning about memory management, Rust just makes you learn it early.

dbaupp4• 11 years ago

You might be thinking of different start-ups, but I was under the impression that start-ups are using Rust not because they want to learn system programming, but because they need the low-level control but aren't confident using C++ and find Rust's compiler-driven safety very compelling.

dbaupp4• 11 years ago

Rust's memory management strategy has been described before as "you have to think about it, but you don't have to worry about it", which I think applies to the language more broadly in terms of a comparison vs. C++. The latter is very flexible and powerful, but generally assumes the programmer is perfect, meaning mistakes often won't be caught at compile time and are often subtle to track down, while Rust has the assumption that humans are fallible, so many mistakes are caught. The fact that they're caught means learning Rust front-loads a pile of things, because the compiler complains about them, which can easily make Rust seem more complicated despite the core concepts of ownership/borrowing really being a subset of modern C++.

vpkaihla2• 11 years ago

If you think any young language can be as complicated as C++, you're trying to be cute or do not actually know how complicated C++ actually is.

prewett• 11 years ago

I've never done anything with Rust, but as a long-time C++ programmer, I expect they have done away with a whole lot of C++ complexity. For example:

Don't forget your & in your function declaration or you'll silently copy objects.

Don't forget to make your destructor virtual in your base class (don't forget to add it if the class wasn't originally going to be a base class!) or you get fun crashes on delete every once in a while.

Use "explicit" with your one-parameter constructors to avoid fun with automatic conversions.

std::string is practically useless

Use "." with classes/structs/references and "->" pointers (why am I the compiler?!)

Think you know what "a = b;" does? Think you know what the =,==,!=,<,>,^,,+,-,/,=,+=,-=,/=,^= operators do? Not unless you checked to see if someone override them!

Ever tried to read some code that uses templates?

If you declared Class(int x) and Class(char x) and then do Class('a'), it silently gets constructed with the integer version (or maybe it's with Class(const char x), can't remember, which should say something right there.)

Quick, what does "const int const x;" mean?

Quick, what does "int* a, b;" do, and is that what you expected?

Is it safe to do "a = b"? You don't know until you read through all the class hierarchies to see if the object has a pointer, and if so, if it has an assignment operator that works properly ("properly" being somewhat relative to the purpose of your object).

Fun times debugging stuff like

if (...)

   statement1;

   statement2;

Can you call a virtual function from a constructor? Which version of C++ are you using?

I have a soft spot in my heart for C++, but boy is there a lot to remember, and the mistakes/typos can kill a good half-day, minimum. I'm excited for the day I have a project I can use Rust on, looking forward to something I don't have to be always on my guard with!

masklinn3• 11 years ago

I know very little C++ and a bit of Rust so there might be mistakes:

Don't forget your & in your function declaration or you'll silently copy objects.

I think this still exists in Rust to a limited extent but it's mitigated:

* Rust uses move semantics by default, so unless the type was specifically marked as Copy[0] it will be moved into the function which should be noticeable

* references are actual types, `&Foo` can't be confused with `Foo` and (outside of method receivers) references are created explicitly, so the callsite knows whether it's passing a reference

Don't forget to make your destructor virtual in your base class (don't forget to add it if the class wasn't originally going to be a base class!) or you get fun crashes on delete every once in a while.

Rust has almost no inheritance support, and the realms of static and dynamic dispatches are pretty well separated (trait objects are dynamic, the rest is mostly static) so that should not be an issue.

Use "explicit" with your one-parameter constructors to avoid fun with automatic conversions.

Rust has very little implicit behaviour (auto-deref is the main one I think), and I don't think it has implicit/automatic conversions.

std::string is practically useless

Without more information as to its failing, I can't say whether String (and &str) is more useful. IME it certainly is useable and useful.

Use "." with classes/structs/references and "->" pointers (why am I the compiler?!)

Yup, this is done through auto-defer (of types implementing the relevant trait of course), though it does have a separate `::` for other context.

Think you know what "a = b;" does? Think you know what the =,==,!=,<,>,^,,+,-,/,=,+=,-=,/=,^= operators do? Not unless you checked to see if someone override them!

Can't override assignment itself, you can override other operators[1] and there is an accepted RFC for overloading augmented assignments[2]. Though these overrides are trait-based which should limit the shenanigan space somewhat.

Ever tried to read some code that uses templates?

Rust's generics are slightly simpler, but they're lacking features (no template specialisation currently) so… not sure.

If you declared Class(int x) and Class(char x) and then do Class('a'), it silently gets constructed with the integer version (or maybe it's with Class(const char x), can't remember, which should say something right there.)

See item above, the very declaration doesn't exist in Rust, you'd need to have two separate factory functions.

Quick, what does "const int const x;" mean?

Should be clearer in rust, type declarations are fairly regular.

Quick, what does "int* a, b;" do, and is that what you expected?

I think that's equivalent to `int* a; int b`?

Type information is an optional postfix addendum in Rust, so the ambiguity doesn't exist, but if you want explicit types you don't get the convenience of shortened declaration. The closest to this code would be

    let (a, b): (Box<u32>, u32)

which isn't much of a gain over

    let a: Box<u32>;
    let b: u32;

if you're not unpacking an existing structure

Is it safe to do "a = b"? You don't know until you read through all the class hierarchies to see if the object has a pointer, and if so, if it has an assignment operator that works properly ("properly" being somewhat relative to the purpose of your object).

See above, assignment itself can't be overloaded (at least at the moment)

Fun times debugging stuff like

I think the only places where braces are optional in Rust are non-ambiguous 1-expression lambdas (`|| {expr}` can be written as `|| expr`) and 1-expression match arms e.g.

    match foo {
        v1 => { expr1 },
        v2 => { expr2 },
    }

can be written

    match foo {
        v1 => expr1,
        v2 => expr2,
    }

> Can you call a virtual function from a constructor?

Rust doesn't have constructors so no. As for the intent, since Rust doesn't have constructors you can't have partially built values (unless you forcefully partially build them) so the answer should still be no.

[0] http://doc.rust-lang.org/std/marker/trait.Copy.html

[1] http://doc.rust-lang.org/std/ops/index.html

[2] https://github.com/rust-lang/rfcs/pull/953

kevindeasis2• 11 years ago

So, I've recently tried to figure out what rust it's been getting lots of attention in HN.

So, it allows you to have safety and control. I thought that is very neat.

I've got three questions for experts. One, what type of applications is Rust intended for?

Two, I like JS because I can code in the client, and server in one language. Will there ever be a web server framework for rust and an api that allows me to modify the dom?

Three, what are your predictions for the future of rust?

glennsl• 11 years ago

1. Rust was designed for low-level systems programming, and in particular the multi-threaded kind, where performance and memory control are important. So things like web browsers (it's been developed alongside development of the Servo web browser), games, operating systems, embedded systems etc. It's basically a better C++.

2. There are already several web frameworks, in various stages of earliness. See [1]. I don't think it will ever be a good idea to write Rust client-side though (even though I believe there is an emscripten backend for it, so it's possible).

3. I see a very bright future for Rust. It could use some ergonomic improvements (but it's miles ahead of C++ even now, mind you), but is otherwise a very well designed language that fits very snuggly in its niche. And it has some very strong backing from Mozilla. I expect it will slowly take over large amounts of territory from C++ and possibly from C, as these developers start to realize the benefits of Rusts safety guarantees. It's also quite unique in that its safety entices many higher-level (python, ruby, C# etc.) developers into trying system programming, which could be really transformative to the system programming scene. For example, one thing that has already come out of this is the cargo package manager, which is similar to npm, bundler etc. but (before cargo) had yet to find its way down to the lowly systems programmers. Many (former?) C++ developers actually tout it as one of the major benefits of Rust.

[1] http://rustyprogrammers.com/2016-01-web-frameworks

kevindeasis2• 11 years ago

Thank you, that was very informative and very helpful! I will definitely start learning Rust!

Cshelton3• 11 years ago

With Web Assembly coming in the near future, Rust will actually be a very great choice. Right now they are targeting c/c++, but Rust of course will be a great alternative.

Do note that, for many things on the web, JavaScript is PLENTY fast. It's when you are doing crazy things like CAD in the browser, it'll be amazing.

imakesnowflakes• 11 years ago

I have looked at both Rust and Go. What I have felt is that, Rust is too restrictive. I mean, you have to fight the compiler a lot harder then you have to do in Go. Some times, for example, if you are writing device drivers or real time embedded programs, then that is great.

But for web services? I think it is overkill. I think Go strikes a nice balance. I would love to be convinced otherwise though. So please tell me, what am I missing?

pjmlp7• 11 years ago

- expressive language, including support for FP

- no need to copy-paste code for generic algorithms

- proper dependencies management

hokutosei• 11 years ago

I'm not using rust for heavy/intense db/API stuffs currently w/Go. but in the future, i'm looking on using it as Main language for our API's. I like how safe it is and its explicitly.

jinst8gmi• 11 years ago

Just waiting for official Jetbrains/IntelliJ support...

jedisct1• 11 years ago

I'm still looking for an _easy_ way to write servers that can handle many TCP connections with Rust.

The native thread/connection model quickly shows its limits, and is very slow on virtualized environments.

mio is as low-level as libevent and just as painful to use.

mioco and coio are very nice but blow the stack after 50k coroutines.

posborne• 11 years ago

Is there a good way to look up no_std crates? For crates written with no_std, is there a keyword we should be tagging things with?

I have several crates providing access to GPIO/SPI/I2C under Linux and would like to put together a roadmap for having the interface to these types of devices that is portable to various platforms and devices (e.g. Linux as well as Zinc, ...).

Announcing Rust 1.6

Related Stories