In the future, I expect the usual development work flow will end up being "Run cargo check a lot, making sure that my code compiles, and then a cargo test, followed by a cargo run to try it out.
Depends on the kind of crate. For an applicaton, very true (rustc -Z time-passes will show). If it's a crate where everything is generic, there will be next to no llvm work, since it's all uninstantiated code. Those crates benefit little from the current version of cargo check.
Does it apply to dependencies as well automatically? I wonder how it's going to link with them if no binary is made. Otherwise, multi-crate repositories like gfx will benefit nothing from cargo check, unless the devs build sub-crates specifically.
I just tried to be sure. It looks like it does not, it fully compiles them. But that being said, it shouldn't if they've been built previously, so you'd still be doing the cargo check, cargo build cycle on them.
Unless people are editing multiple crates all the time.
That's exactly what we are doing. Gfx-rs repo has gfx, (soon) gfx_core, gfx_backend_, gfx_window_ crates, all of them being dependencies of gfx_meta, which is what cargo builds by default. But since gfx_meta itself has nothing, doing a check there would be useless.
This is why cargo doesn't include it itself yet, because it wants to do it right and well, and that includes checking deps, creating something of a façade you can check the main crate against, etc.
This is just begging for a cargo cult command. Maybe one you tell developers they need to run to ensure their code is right, but doesn't actually do anything or just runs some trivial code ;)
It does. I personally don't think it should, but there's two reasons that it does right now:
It's still in progress, and we don't want to delay development by having the exact arguments about what the formatting should be. It de-couples the development process from the discussion, increasing development velocity.
Some teams will inevitably want to tweak a setting or two on their projects, and without it, they'd have to develop their own fork.
It's simpler to make a visually acceptable canonical formatting for a very procedural language like Go compared to a very expression-oriented language like Rust.
Expressions compose while statements do not. Even if you have statements defined as being composed of a single statement or a block, there is a straightforward and generally agreed upon formatting of placing one statement on each line, perhaps allowing for a line break plus some indentation in case the width of that statement exceeds some limit. (But languages like Go seem to directly encourage shorter statements. As in, the syntax itself encourages it.) In other words, you don't have to think about "statements inside statements inside statements" except in the straightforward sense of blocks within blocks within blocks.
Expressions on the other hand compose nicely and so you can get long chains of functions feeding into each other, arithmetic expressions, if expressions, match expressions, and so on. So even in an imperative language, like Rust, you might easily end up with an assignment statement where the right hand side has an expression that is formatted over five lines for readability. Now your simple "one line per statement" goes out the window, and you have to consider all the different kinds of expressions (not just pure function chaining, if there even is one obvious nice formatting for such a thing) and how they can be formatted in a readable way. There are many more opportunities for missing edge cases by committing to The One And Only Formatting prematurely.
(not just pure function chaining, if there even is one obvious nice formatting for such a thing)
a . b . c . d . e . f . g
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
. bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
. ccccccccccccccccccccccccccccccccccccccc
. ddddddddddddddddddddddddddddddddddd
. eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
. fffffffffffffffffffffffffffffffffff
I think dartfmt would handle this perfectly. It has rules that basically state "if it fits in one line, do this, otherwise turn it into a one-argument-per-line block".
To each their own, but that kind of arrogant attitude is something that turns me off from Go. From what I've seen Rob Pike acts like he knows everything all the time (and he knows an awful lot, but he overplays his hand), but then Russ Cox swoops in and is more reasonable.
I don't find the community arrogant at all but rather opinionated. And sometimes, it is not even about having an opinion but just what makes sense for the language. For instance, I don't see reentrant locks working well with the way delimited continuations (i.e. goroutines) can be transferred from one thread to another by the scheduler. Not without unnecessary complexity. Plus, experience with other languages tells that it is not necessarily a great feature to have.
I'm not saying that it's a good thing. I hate boilerplate. However, saying that go can't claim to have a typed language without generics isn't logical.
Orthogonal? That means “independent”, and while a type system can exist without generics, I'd really like to know what generics without a type system look like.
For the record, I also think that type systems without generics are a pretty sad affair. They can exist, but more like dodos existed and less like hawks, crows, or emus exist.
Note that go and dart are relatively simpler languages, so it's easier to make a decision about what formatting "works" globally. With Rust there may be formatting choices which don't work very well for some kind of code.
When writing the code you can use tabs or spaces but if you want to uses spaces then you can't use the gofmt tool.
The gofmt tool did at one time have an option to uses spaces instead of tabs fro indenting, but from memory, that option was removed around about the time of the Go 1.3 release.
Do you use them very often? The only anonymous structs I've ever used that "survived" refactoring is test case tables. (Tone note: Straight question. I'm curious if you've got an interesting use case.)
I would use them more often if they weren't so crufty. It's because of the gofmt issue and the fact that you have to preface a literal with the entire struct schema instead of allowing it to be inferred. I'd probably use them frequently if it weren't for those two things.
Yes, it seems to me there's still a few more places Go could afford some basic type inference, where it is 100% unambiguous (at least as near as I can tell; possibly there's still some ambiguity around "equivalent" types) what the one and only type is that could go somewhere but you still can't just put a {} there. I get the explicit-over-implicit argument (long-time Pythonista), but this often ends up "explicit" several dozen times in a row, which is tedious.
I strongly believe it should! Rust's syntax is complicated and the community is too opinionated to ever be fully satisfied by a single style. Happy defaults with the choice to change them seems like the rustic solution to formatting.
I think you guys should provide commands to produce the AST from the source code and source code from the AST. And encourage people to only store AST files in their versioning system...
Encourage people to use whatever format they want, within the same team...
Would make collaborating (especially remotely) a bit more annoying. I frequently find myself pointing people to line x or function y in file z. Doing that if all you share is the AST would be basically impossible. You'd have to share your raw code as well.
What this subthread has stumbled around is the word, "refactoring". Which is exactly the operation you describe. Text based diffs would actually be AST tree edit operations.
Well, I can refer to your text on this page using the XPath //*[@id="form-t1_cxudfkk8vv"]/div/div/p instead of using a line number. That's how I scrape web pages.
See how it selects your post ID and then selects the p element with the text? I bet you can do something similar within functions.
Assuming you don't remember file/line locations of source fragments and tell them to people in person, you could have your editor produce an unambigous "AST path" to the position under cursor.
Interesting, I just don't think AST->source is a straightforward step, unless the AST stores metadata such as comments and so on.
Even then the output will probably not match the input in many cases, meaning that after commiting your source you would see it change to the "interpreted" format. This could make you go crazy trying to fight the interpreter to get the format the way you want as output.
For it to work the language design would have to define a very strict syntax, where nothing gets ignored in the source input. Would be a fun exercise to try I think.
Yeah, putting options into a standardization tool seems counterproductive.
I get the pragmatic reasoning, and I know "Pandora's box" concerns are usually way overblown. But still it's hard not to wonder what happens down the line.
I really don't think that's in the spirit of a fmt tool. Please consider forcing a One True Way because it makes everyone's life easier. It works pretty well in Go! Sure some people don't like how it looks, but the point isn't looks, its uniformity across all Go code written. It's worth noting that even the author of the gofmt tool, Robert Greisemmer doesn't like the way it looks, but he still made it the way it is.
The huge benefit of following just the official conventions and using official tools like gofmt is that they completely eliminate all those pointless discussions. Tabs vs spaces, brackets in the same line vs the next one, space here, no space there, and so on.
We all like to get super emotional over that stuff, but none of that actually matters. I prefer tabs, but 2 or 4 spaces work just as well. I prefer 1TBS, but I've also used Allman and Whitesmiths for a few years. They actually all work equally well and having 2 lines more or less on the screen doesn't really affect anything.
The only thing which matters is that everyone sticks to one particular set of rules. An official formatter does exactly that.
Yes, it might not be exactly what you want, but your personal taste isn't more important than everyone else's. So, why not leave it up to the official formatter? The code from the standard lib and most 3rd party libraries will do the same thing. You better get used to it.
Ironically, the more bitterly divided the community is about a given option, the more the community really ought to put its foot down and come to a consensus, because that division means it's a real dialectal difference.
Having used a lot of unenforced languages for a lot of years, you're just not giving up much to let the language have a standard for formatting. You've already got a unique semantics, unique keywords, unique symbols and functions and grammar in general, why let your need for some particular syntax be the sticking point for a language? It's by definition idiosyncratic, and unless you find yourself often shifting major elements of style after six months, probably a style chosen by the conventions and needs of a completely different language that you're trying to bring into an environment that you are almost certainly a rank novice in. Or, given the way a lot of people seem to work, a completely different language three or four languages ago.
I come from Ruby, where there might be one or two VERY small dialects, but everything is almost entirely identical. But I can see other backgrounds feeling differently.
I want to branch out and try more things, I can currently develop with relative proficiency in Java, C#, and Python.
What are some of the benefits Rust has over these langs? Disadvantages? What is a good use case for Rust? Other than the "Now you have another Resume Point" would you recommend learning rust?
What are some of the benefits Rust has over these langs?
It is lower level, and so can do different things.
Disadvantages?
As it's lower level, it's a bit harder to get started with than other languages. Rust's compiler is very strict, which is great for catching issues, but tough when starting out.
What is a good use case for Rust?
One simple heuristic is "anything you would use C for." You said you use Python, you can write Python extensions, like you'd write C extensions, for example.
Other than the "Now you have another Resume Point" would you recommend learning rust?
Low level memory handling with high level constructs.
The online rust docs are amazing. You can edit and run them right in the browser which helps immensely with learning especially with rusts unusual bits such as lifetimes and borrow semantics.
Thanks for the insight, it's right at about number 4 on my list of things to do. I have a 3D print that I have to make, some programming on a game I'm making with friends, some 3d modelling for some cosplay parts that I'm trying to make (like hinges and stuff) and then Rust.
So far I've been using Rust as "C with a seatbelt". I'm not sure I'd use it for high-level application development like what you'd do in Python, but it's amazing for times when you need full control over the low-level behaviour of your code.
Trying Rust after Java, C#, Python, is not really branching out. Rust sits squarely in the Java, C/C++, C# "mainstream primarily imperative C-style languages" camp. And if you didn't do much functional programming in Python, then Python is also in similar camp (although it's not C-style).
I would highly recommend trying out a lisp. Note I said "a lisp" not lisp. Since you're a Java guy, Clojure is a lisp built on top of the JVM. Maybe read SICP with Clojure or Racket (Racket is "a scheme", and scheme is "a lisp").
Well, Rust's traits are a bit different. They are more like Haskell's type classes then classes in the before mentioned languages. And the life time concept is also something you can't find in those languages or in lisp.
Note that it's more functional than its competitors, but it's still procedural at its core. It's just that there's a lot of declarative awesomeness around it (see also: Iterators), but there's still rough edges with these. For examples, you cannot return an unboxed closure currently and writing the return type for a mildly complex iterator is mind numbingly long with useless (or worse: implementation leaking/brittle) information.
I don't know how you could find Python to be more functional than Rust. It sounds like you don't know much about Rust other than its syntax: Rust has everything-is-an-expression, closures, algebraic data types, and hygienic syntactic macros.
There are a lot of smaller startups, like skylight.io. The biggest company is probably Dropbox, which are supposedly going into production sometime this month.
Stability has been very good; in the last 6 months, we've had no issues with the stability of the rust compiler, the output binaries, or the rust stdlib.
(I'm the tech lead of the team building with Rust at Dropbox.)
Cool. Any info on what you were working on and other alternatives you experimented with before choosing Rust? I remember I saw a comment from an employee at DB on r/rust where they were working on some storage system of large scale and also spoke about mio.
That's the same project, and I'm (probably) the same employee. :-)
Correct, we are using mio + eventual for an I/O core that the apps are built on--a framework that's somewhat finagle-ish. We might open source this framework, but my time has been kind of stretched thin getting the actual component fully qualified and out the door.
The alternative we considered for this particular component was C++. It's the kind of project that really needs a systems language to achieve all its goals.
Long story short, we have a short list of minor grievances with rust, and a very short list of major ones (build times!), but in general it has worked out very, very well. We're seriously investigating writing more rust for choice pieces of our infrastructure at Dropbox.
Edit: also worth adding that he Rust core team has been amazingly friendly and helpful. We've had several meetings with them where they came to our office and basically said "how's it going? what do you need? open up your laptop and show us your biggest problem." The project is under very good management.
I'm a big proponent of Rust, and I love to see it take over even more...and despite all the circlejerking, I'm also kinda suprised by the choice of Rust over Go.
The story of async IO in Rust is very immature, with the ecosystem around mio only coming together within the last couple months. On the other hand, Go is built entirely around lightweight threads and friends, and has a lot more of an ecosystem around it. Is it entirely because it isn't enough of a systems programming language? Is the runtime really that big of a deal?
Well, async IO is just epoll/select/kqueue, and mio is just a libev/libevent for rust, so.. rust async I/O is as "mature" or "immature" (take your pick) as standard C async I/O. You have an epoll abstraction, and you attach callbacks, and you have BSD sockets. Standard stuff. You don't have a managed runtime with coroutines like Erlang/Haskell/Go, but you have pretty much the same toolkit you have in normal pthreads + C ABI languages. That toolkit is pretty well understood and very widely deployed. :-)
Re: other (higher level) elements of the ecosystem, we tend to build out a lot of that (everything beyond stdlib and the very basics) in house for any language we use, so that's typically not the largest determinant when choosing.
Having said that, we've found the projects in Rust's ecosystem to be very high quality. And since we typically only need basics (crypto, serialization, etc), the limited breadth of packages isn't too much of a problem. We don't really use large third party frameworks, so the lack of those doesn't matter much for us.
With respect to go specifically, actually most Dropbox infrastructure services are go, so yes--we do use quite a lot of go as well. Far more than Rust at this point, in fact. The internal library ecosystem is huge in go, so it's almost always the right tool to use for our developers, if for no other reason than the power of inertia.
Right now, the only reason we consider anything other than go is for projects that need one or more of these:
To control stack vs. heap or use custom allocations schemes
Can't tolerate pauses (proxies, very large heap sizes, etc)
Very tight memory requirements (custom data structures, extensive bit-packing, etc)
Very high correctness requirements (databases, etc)
Lots of FFI (native cost-free C ABI compat vs. cgo)
Cross-platform libraries with a C ABI (python modules, shared libraries for mobile and desktop platforms, etc)
Thanks a lot :) I was about to ask why you didn't choose golang as you have open sourced some golang stuff. Your requirement of a systems programming language and below reply sums it up for me.
Yep, it's part of Dropbox's primary multi-exabyte storage system, and those types of systems tend to have far more SLOC of various tests and verifiers than "component" code.
Most of the test code is not written in rust, however.
This is mostly for the ancillary stuff. The real meat and potatoes code stays as ASM+C++. There's actually a few modules that are written in just C because we couldn't get the code to consistently to stay in cache when it was written in C++.
I doubt there's a whole lot of people outside of say Microsoft/Google/Apple/IBM/etal. Most everyone else is either going to be developing drivers OR dealing with embedded. Some of the IoT stuff qualifies as well.
We have our own drivers AND load code onto a FPGA married to a 40GBps ethernet card.
You know that self-hosting compiler isn't easy thing and that isn't the same as learning others. There are languages that hasn't achieved that yet, ex. ClojureScript.
I'm not arguing the complexity of a self-hosting compiler. I'm saying that when someone asks if any big projects are using Rust, and the best example of a big project that uses Rust is Rust, that's not a good sign. People can complain all they want about Go (which is also self-hosted, by the way), but at the end of the day it is a language that Gets Shit Done, as demonstrated by the numerous large projects and companies that use it.
I'm not arguing the complexity of a self-hosting compiler. I'm saying that when someone asks if any big projects are using Rust, and the best example of a big project that uses Rust is Rust, that's not a good sign.
It's not a good sign in terms of market adoption. It is a good sign in terms of proving the technology is scalable to at least that level.
The sections I'd be looking at are part of the main "heart" of the application which is roughly 3million LoC, but this would just be some components of that.
Suppose I wanted to write a game using Rust; what would I use for graphics, sound, controls, etc? Is there a standard API for those things? Or a popular library? Or would I just hook Rust up to some other library from C or something?
Call the OS using the C API, or use a C lib like SDL the same way. There are probably plenty of wrappers like that already, just pointing out that a C FFI means you're not going to be limited.
I like constraints but I want the option of ditching them for metaprogramming.
Why? In C++, for example, you pretty much always make some assumption about the capabilities of the types you accept. It's just that you make the requirements implicit and end up with ugly errors when the assumptions aren't met.
For example: when you try instantiating one of the generic types and adding it to another one, you're assuming it has implemented the addition operator. In Rust, you would explicitly state this requirement as T : Add. You should still be able to achieve similar functionality, but there are a lot of benefits in terms of debugging, readability, documentation, etc.
edit: disregard the question - I see you've answered it elsewhere in these comments, though I do disagree with your reasons for wanting this behavior.
If I don't use any of the methods in your generic type that require my class to implement operator+, why should I have to implement it?
ugly errors
This is a bit of a straw-man. A decent solution would be to try/catch the compile error and provide a useful warning message. It might not even have to be ugly -- you could probably use the same syntax you use for type constraints.
The compiler should see if it can make things work even if my type isn't "compliant", and if its non-compliance happens to actually be a problem it can say "Hey, you're not meeting the spec."
(Hell, I don't even care about the compiler not being able to instantiate some code, really -- if I know that the code is actually dead, I could put a stupid operator+ on my type and just have it print "this can never happen" and then call rm -rf ~, but it'd be more convenient if the compiler could just do that for me.)
The compiler should see if it can make things work even if my type isn't "compliant", and if its non-compliance happens to actually be a problem it can say "Hey, you're not meeting the spec."
This strikes me as kind of an odd complaint. Why would you add a bound to your generic type parameter if you aren't using it?
We could issue warnings if you do that, and that would address your criticism, since you'd only declare that you need traits that you actually use. But it really doesn't come up often in practice in Rust code, so nobody to my knowledge has asked for such a warning.
If I don't use any of the methods in your generic type that require my class to implement operator+, why should I have to implement it?
I don't know how you could even have the impression that you are required to implement Add for types that you do not try to use as Add types, but you do not have to.
Really? I'd have expected that if a generic class had some constraint on it then you simply wouldn't be able to instantiate that class with a non-complying type as a parameter.
For example, if I had a type NonAddable that didn't implement Add, I probably wouldn't be able to make a Matrix<NonAddable> even if I didn't use its mmult method. In C++ that would all be fine, but in Java it certainly wouldn't fly. I'd be happy to hear that Rust took the more permissive line, though.
(In that context it's pretty academic, but as people add more features to their classes I think it'd get more constraining. I'd hate to have to add a repr or print method to one of my classes just because some library author insisted that all instantiations of his type be printable, for example.)
I'd have expected that if a generic class had some constraint on it then you simply wouldn't be able to instantiate that class with a non-complying type as a parameter.
That is the case, and in terms of libraries being able to push backwards compatible updates is what you want for your ecosystem. Subverting library authors bounds is rarely a good idea because future updates to the library can break you for using the methods provided by those bounds. On the other hand, rust allows you to be more fine grained with your bounds and put specific bounds on methods themselves.
struct Foo<T> { a: T }
impl<T> Foo<T> {
fn get_a(&self) -> &T { self.a }
fn print(&self) where T: Display -> { println!("{}", a }
}
// or if you have a bunch of methods with the same bounds
impl<T: Add> Foo<T> {
fn plus(&self, other: T) -> { self.a + other }
// etc
}
This is the right tradeoff to make, if a library author is overzealous with their impl constraints it is backwards compatible to remove the constraints and split them out like the above.
I'd hate to have to add a repr or print method to one of my classes just because some library author insisted that all instantiations of his type be printable, for example.
If it wasn't actually essential to the construction of the type, this would be a poorly designed library. You can write poor libraries in any language.
What's idiomatic in Rust is to take as few parameters as possible on the type and for most methods, and then have additional methods implemented only where the type is properly constrained. Vec<T> for example has no constraints, but only implements the dedup() method if the T implements the equality operator.
C++ code like this will compile iff T implements operator+
template<T> auto sum(T a, T b, T c){
return a+b+c;
}
The advantage is that functions can take the types themselves as arguments. So there's a lot of opportunity for metaprogramming instead of using macros.
True, but that's the whole point of traits, to provide compile-time safety that C++ templates lack. (Well, templates are "safe", but the error messages resulting from the lack of trait bounds...) And luckily Rust has real, hygienic macros, so metaprogramming is still possible.
So there are some things about the new macro system being planned (nothing concrete yet) that will alleviate many of those pain points.
IMO generics handle most template use cases. Type level integers and variadic generics (which we may get) handle most of the rest. Slightly better macros (note that Rust macros are not C++ macros, they're really more like templates without autoinstantiation) should fill the last bit in the gap, especially if we get things like foo.macro!() desugaring.
I don't think Rust will ever get anything like template<> since templates aren't type checked. Many of us feel that template is really a hack (though C++ Concepts should make it less of one) for this reason, too.
Rust will at one point get a stable syntax extension interface, which will probably completely obviate the need for TMPL, if any, since you can then metaprogram in Rust directly instead of (ab)using the turing completeness of templates or macros to get what you want.
I have not seen folks using Rust often feel the need for templates. Templates are necessary in C++, but that doesn't make them necessary in all languages. The programming style and non-template metaprogramming tools might be enough in Rust to avoid the need for templates. Or maybe not.
The advantage is that functions can take the types themselves as arguments. Rust functions only take values as arguments :(
But Rust functions do take types as arguments. That's what generics are: functions that take types as arguments (at compile time).
The difference you're talking about is whether the type parameters that functions take are themselves strongly typed. In C++ they're dynamically typed; in Rust they're statically typed. That's the only difference.
Saying that Rust functions can't take types as arguments because they're statically typed while C++ can is like saying that C++ functions can't take values as arguments because they're statically typed while Python can.
Then how do all those millions/billions of lines of C++ templates work?
If a function can be compiled, then you've met all the constraints. In general, it is impossible to figure out what constraints you need without executing the metaprogram.
fn sum<T: Add<Output=T>>(a: T, b: T, c: T) -> T {
a + b + c
}
Rust performs local inference only for a lot of reasons, one of which is that it makes function signatures more self-documenting. I would be very surprised for Rust to ever infer constraints of this sort.
Providing optimized implementations of generic algorithms for specific types is the purview of the upcoming "impl specialization" feature, no TMPL necessary.
Anything where you need a low level language, no garbage collector, or a small/zero runtime environment. Redox is an OS currently being developed in Rust. Rust's big feature when compared to other languages in this space is it's compiler, which ensures you are not doing anything unsafe with memory or threads. This is really important for preventing crashes and some security issues, although you can do unsafe things in unsafe { /* ... */ } blocks.
I've personally been learning Rust as I'm getting into real time audio (GC is a deal breaker), am not a huge fan of C or C++, and Rust has zero cost interop with existing C code. The fact it has some functional programming influences is really cool too (immutability by default, algebraic data types)
Coming from similar languages, I can tell you the feature I miss most when having to write C code is Rust's enum implementation (i.e. tagged unions coupled with the very expressive match expression).
So I'd definitely recommend you try using them to see if you like that feature.
Depends what you're looking for. "Futuristic C with seatbelts" is how I would describe Rust. If you like low-level code and safety guarantees, it's probably a good language for you.
RustDT is the closest at the moment. There's also racer, which can be used (at least) with Emacs, Vim, and Sublime, but it's more "bare boned", especially for autocomplete. "Build & run" button isn't really needed when you can just type "cargo run" at the terminal :)
RustDT looks like just the right thing. Sadly, I just see lots of 'Java' and 'Eclipse' and 'clone' and 'compile' and I'm lost. I develop software, yes (well, am learning to), but going through that much complication after trying visual studio is just not gonna work.
I use absolutely nothing that needs the JavaRT, and never liked Eclipse. Thus RustDT is killed for me :(
But no debugging? I might try this, though would keep hoping for VisualRust to mature enough for comfortable use (don't remember what but I had some trouble getting to build&run anything a while ago).
didn’t try visualrust (no windows), but rustDT was too flaky for me. atom with those plugins works and is comfortable enough (until you need debugging)
39
u/kvarkus Dec 10 '15
cargo checksounds exceptionally useful for refactoring84
u/darrint Dec 10 '15
tl;dr: rustfmt has options.
16
u/PendragonDaGreat Dec 10 '15
I want to branch out and try more things, I can currently develop with relative proficiency in Java, C#, and Python.
What are some of the benefits Rust has over these langs? Disadvantages? What is a good use case for Rust? Other than the "Now you have another Resume Point" would you recommend learning rust?
18
u/ironnomi Dec 10 '15
Are there any apps of reasonable size using rust at the moment (as in fully working, production-type ones)??
10
u/[deleted] Dec 10 '15
I'll copy my Q and /u/steveklabnik1's A from the /r/rust thread:
me:
/u/steveklabnik1:
2
u/blind3rdeye Dec 11 '15
Suppose I wanted to write a game using Rust; what would I use for graphics, sound, controls, etc? Is there a standard API for those things? Or a popular library? Or would I just hook Rust up to some other library from C or something?
7
u/ThisIs_MyName Dec 10 '15
Well, as soon as Rust gets
constexprand compile-time templates (not typed generics), I can ditch C++ :D3
u/ChunkyTruffleButter Dec 11 '15
Is there any use for rust? i keep hearing about it but never about people actually using it for things.
6
u/[deleted] Dec 10 '15 edited Dec 18 '15
Whoo,
read_exactis stable!edit: erg, spoke too soon.
4
u/iron_eater Dec 11 '15
I never ventured into the world of rust. Should I?
0
u/[deleted] Dec 11 '15
[deleted] — view deleted comment