10 ms·
State of Rust Survey 2016
- deleted 10y ago[deleted]
- shrugger2 10y agoNo mention of ANSI standard efforts still. It blows my mind that literally ANYONE would bother with systems programming in a language with no standardized spec of some sort. Rust's 'whatever is in the repo is standard behavior' is the sort of perl nonsense that set them back for so many years.
- bishop_mandible 10y agoAs many women as trans people (1.6%).
- minimaxir 10y agoThat's actually a poorly-constucted survey question since a person can be a part of several underrepresented demographics in technology, which makes percentage breakdowns inaccurate.
- thenewwazoo 10y agoThe percentages total 106.6%.
- erickt 10y agoAs I mentioned in my prior post, consider the percentages against the total number of responders, rather than across each demographic.
- vardump 10y agoYup. Total is 3138 [1], not 2942. 196 are unaccounted for. Maybe the survey form let you choose two or more different groups? From the article: > A huge thank you to the 3,086 people who responded! 3138 is also more than the number of respondents. [1]: (2402+86+51+189+159+73+47+47+84)/2942 = 1.0666
- masklinn 10y ago> Maybe the form let you choose two or more different groups? Yes, since you can be a member of multiple groups.
- erickt 10y agoRust Community Team member here. This survey question allowed for people to describe themselves as they decided, and so people could select multiple choices if they wanted, as well as enter in free text. The percentages John used in this writeup should just be compared to the total number of people that replied, rather than across each of these demographics.
- iskander 10y agoIt's possible that all the women who answered this survey were trans (since those two categories don't exclude each other).
- kibwen 10y agoI've met most of my trans friends (three out of four) through Rust, it's indeed interesting that Rust apparently manages to appeal to such a specific demographic.
- squiguy7 10y agoMy favorite part about this survey is that for many of the questions there is a majority agreement. Many developers believe that tooling needs to improve or that crates should work with stable features. I think this is great for the Rust team going forward knowing that they will act on it.
- steveklabnik 10y agoA component of this that's also nice is that there weren't any real surprises: if you had asked me what needs to improve, I would have said the same thing the survey did overall. So it was really cool/nice to see our suspicions confirmed, and knowing that we are already working on some of this stuff.
- kartD 10y agoIt's early days for Rust, there will be general agreement on what needs work because it's usually obvious and everyone has roughly the same experience with the language. I feel the difficulty comes when the language ages and the most apparent problems have been tackled. Take Python, what's needed: async ? GIL fix ? more functional? faster execution?
- kibwen 10y ago> async ? GIL fix ? more functional? faster execution? Three out of these four boil down to "this isn't fast enough", which makes it seem as though the Python community is unified in understanding the problems it faces. :P
- kartD 10y agoThis could also be because of my limited knowledge of the Python community :P
- JoshTriplett 10y agoI'm curious if there were any significant responses to the tooling/ecosystem questions regarding packaging and integration with Linux distributions. I'd like to provide an application written in Rust in major Linux distributions. "cargo install" will not work, both because it depends on network access, and because it pulls in dependencies from outside the distribution. Similarly, many distributions have policies against bundling library sources in the application. There needs to be a straightforward way to turn a source package with a Cargo.toml file into a package for Debian and Fedora that depends on other packages corresponding to its Cargo dependencies (and C library dependencies).
- steveklabnik 10y agoCargo install was never intended to be used that way. It's for things useful for Rust developers, not for people who use a program who happen to be written in Rust. There's a few things at play here. For "build from source" distros, we've been making some changes to make it easier to package rustc. Namely, instead of relying on a specific SHA of the compiler to bootstrap, starting with 1.10, it will build with 1.9, and 1.11 will build with 1.10. This is much, much easier for distros. As for Cargo dependencies on those packages, we'll see. There's a few ways it could go, but we need the compiler distribution sorted first. A second is that we'd like to eventually have tooling to make giving you a .deb or .rpm or whatever easier: https://github.com/mmstick/cargo-deb https://github.com/mmstick/cargo-deb is an example of such a tool. This won't necessarily be good enough to go into Debian proper; I know they tend to not like these kinds of tools, and want to do it by hand. But "Hey thanks for visiting my website, here is a thing you can download and install", these kinds of packages can be made with this kind of tooling. In general, it's complex work, as then, these issues are also different per distro or distro family. We'll get there :)
- JoshTriplett 10y agoI was more looking for a path to producing Policy-compliant packages for Debian and other distributions. Do you know of anyone working on that right now, and how I can help?
- kej 10y agoI'm disappointed that "No" and "I stopped using Rust" were merged into one answer for the "Do you use Rust?" question. Knowing the reasons people have never used Rust compared to the reasons people have used Rust but moved away would have been a really interesting result.
- steveklabnik 10y agoYou live and learn. I think we're all kicking ourselves over it; so obvious in hindsight! It's certainly the plan for next year.
- erickt 10y agoRust Community Team here. Yeah that was a mistake. We were trying to cut out redundant questions, but it would have been so easy just to split this into three answers. We might be able to split this out based on secondary information, but we didn't finish that analysis in time for this post. Maybe we can get it into a future post if we trust our result.
- Animats 10y agoThat's a good point. Since this is apparently a self-selected sample of people interested in Rust, a 1/3 "No" report is a problem. If the survey was from a random sample of all programmers, the usage level would be much lower.
- pcwalton 10y ago> Since this is apparently a self-selected sample of people interested in Rust, a 1/3 "No" report is a problem. How do you know what usage level is a "problem" without any point of comparison? I'm interested in JavaScript, for example, but I don't use it more often than a handful of times per year, if that. I wouldn't be surprised if a third of people answering a JS survey were in the same boat. And I'm not worried about the future of JS. > If the survey was from a random sample of all programmers, the usage level would be much lower. Is there any language which more than a small minority of all programmers in the world use?
- bahjoite 10y ago"Person of color": perhaps this answer had so few responses because few people identify as being a person of colour. The wording does seem rather twentieth century.
- douche 10y agoI feel like we talked about this already https://news.ycombinator.com/item?id=11959232 https://news.ycombinator.com/item?id=11959232
- bahjoite 10y agoThank you. This reddit thread discusses it some: https://www.reddit.com/r/rust/comments/4ikawg/launching_the_2016_state_of_rust_survey/d2yyb41 https://www.reddit.com/r/rust/comments/4ikawg/launching_the_... plus there's this little gem[0]: 'Talking with my Korean friends here in Korea, I found that they didn't check "person of color" checkbox because they had no idea what that is. Typical response: "does it mean person with colorful personality?" Just for your information.' [0]: https://www.reddit.com/r/rust/comments/4ikawg/launching_the_2016_state_of_rust_survey/d2zpndo https://www.reddit.com/r/rust/comments/4ikawg/launching_the_...
- deleted 10y ago[deleted]
- dom96 10y agoThank you for publishing the results of this survey. It has inspired a similar survey for the Nim programming language[1] that is still open, so please take a look if you have a spare couple of minutes. It will be very interesting to see how the results differ between Rust and Nim. 1 - http://nim-lang.org/news/2016_06_23_launching_the_2016_nim_community_survey.html http://nim-lang.org/news/2016_06_23_launching_the_2016_nim_c...
- vegabook 10y agoAre disabled people "under represented in technology"? Just a question... I have fused wrists from a motorcylce accident. It's inconvenient and I cannot drive or play most sports, but I don't consider myself disabled. Am I under-represented? Do I self-identify as disabled? No. Would others in my position? Maybe... I guess that's a question about disabled threshold... Do wheelchair bound people identify as "under-represented in technology"? I don't even know. All I know is that some of them may say yes, and some of them may say no. So we don't know who is in the 81%. Gay - are gay people "under-represented in technology"? Somehow I doubt it. Again same problem. You're gay. You're part of a minority group, definitely. But are you "under-represented in technology"? Wouldn't it have been better just to spell out the categories and ask people if they are in them? "Are you white", "how old are you?", "black", "gay", "trans", "female", "disabled" etc?
- erickt 10y agoRust Community Team lead here. It is fine if people don't consider themselves underrepresented, we just want to be proactive about discovering if people end up self selecting themselves out of our community because they don't feel welcome. Furthermore, we are starting some initiatives to focus growing a diverse group of participants (https://github.com/rust-community/RustBridge https://github.com/rust-community/RustBridge), and so we need some baselines to see if we are successful or not. We did have a number of categories that people could select from. Our plan for next year is to identify groups from the free text for next year. We are tracking our improvement plans here: https://github.com/rust-community/team/issues/28 https://github.com/rust-community/team/issues/28
- vegabook 10y agogot it - sounds like I probably misunderstood the motivation which appears to have been less about demographics than about under-representation identification. Kudos on the whole survey and this particular section, my nitpick aside, I find the whole thing highly interesting and am personally impressed by your desire to know your user base in this way. Not a Rust user yet as I am a scientific programmer and on the exploratory side I really need a REPL, but I will make an effort to look at Rust for the parallel side of our production code.
- MichaelGG 10y agoIf items ("fn" definitions) implemented type inference instead of requiring the programmer to manually document something the compiler can figure out, the learning curve would be easier. Especially with tooling that shows the type of any given expression (integrated with an editor).
- pcwalton 10y ago> If items ("fn" definitions) implemented type inference instead of requiring the programmer to manually document something the compiler can figure out, the learning curve would be easier. No, it wouldn't. Not when the compiler is spewing error messages about types you didn't even mention, especially if the compiler inferred that type on the basis of code in some random other file you didn't know about.
- MichaelGG 10y agoGuess our experiences are different. In F# I do this all the time, and I've never had it be an issue. In Rust, if I'm trying to play around with something, I have to figure out the signatures even when there's only one option. I hear this argument that the inferred types will be confusing (from C#, F#, and Rust communities; I'm sure it exists in others) -- but they will be accurate! It's something the human has to figure out anyways, except without computer assistance. All because of some misguided attempt at enforcing documentation guidelines and verbosity on programmers, sight-unseen. I guess users can wait for IDE support with a "show inferred types" option. Edit: And just as a note, I really love Rust. My only core complaint is the verbosity. And that's a small price to pay since I'd either be paying with perf/memory usage (more expressive languages) or bugs and far more verbosity (C).
- kibwen 10y ago> All because of some misguided attempt at enforcing > documentation guidelines and verbosity on programmers, > sight-unseen. Characterizing the tradeoff in this way is very uncharitable. In Rust, function signatures are the absolute source of truth about the contract that a given function upholds. In systems with global type inference, the entire program is the source of absolute truth for any function whose parameters are inferred, and local reasoning becomes much more difficult.
- firebones 10y agoGood start for a year one survey. I'm surprised there aren't more Java devs responding. Rust is characterized as a systems programming language, but Java is a language that has made incursions down into the C/C++ "systems programming" space over the last decade than any other language, and it is ripe for disruption by Rust due to Rust's superior efficiency. In agreement with the survey, I believe this will not happen until there's good IDE support, and until more hardened enterprise-y dependencies/libraries emerge (e.g., database access to things like Oracle via OCI or ODBC). After an extended run with Rust, I returned to the Java 8 world briefly shocked to find a) how much more productive a good IDE made me and b) how productive such an IDE made me in terms of writing inefficient code! In there lies an opportunity. Rust should be attacking Java from below. The waste in a typical Java stack should make us all weep. The only barrier I see is perception around the ownership learning curve. In bouncing between languages, what Rust lacks (and what other languages have) is the ability to pass the sip test...the first experience. Out of the box, untuned Java screams due to JIT and the IDEs; it's only far later when you try to do something serious that you feel the cost of the abstractions that help productivity, and you're in a forest of JVM tuning options and writing non-idiomatic Java code in order to get reliably performance and behavior. Rust requires too much faith at this point--that the microbenchmarks matter and that investment in mastering the borrow checker will pay off with more stable performance and behavior later. Other points: Cargo is underrated. Traits over primitives is a huge win over Java's boxed collections. Community involvement and health is underrated. Keep up the good work.
- deleted 10y ago[deleted]
- firebones 10y agoSomeone posted a great question here that they later deleted. My full response also wasn't submitted (and lost), so I'm trying to recreate part of it here. It was actually a good question about whether Rust's efficiency has been tested. I've done some testing; Java is faster in terms of the sip test for a lot of stuff, especially for cases where you micro-benchmark single processes without regard to overall CPU or memory usage. However, when you scale up (to the point where JVM tuning comes into play), the raw performance in terms of response time is comparable, while the overall system utilization (e.g., "time" measurements of user/sys) is much better for Rust--Java uses a lot more system time due to JVM housekeeping threads. So more efficient is not a win for Java, even though wall-clock benchmark time might look better for a single process (as long as you don't look at overall system utilization.) Java's performance comes at the price of more memory usage and higher variance in response time. You can attempt to constrain one or the other, but you can't constrain both at the same time. Microbenchmarks typically put a high enough ceiling on memory that they're relevant for very constrained loads. To be robust beyond the microbenchmark, incremental GC is required, which levels the playing field between Java GC and Rust's jemalloc. Still, even when you attain parity, the Java solution is using far more memory due to the JVM's OOP overhead. Another example of a hidden "cost" of Rust comes from things like Unicode support. Recently I tested a regex-heavy algorithm that used burntsushi's regex library for Rust. In initial testing, Java blew it away. What I later realized was that the default Java implementation I used did not support Unicode characters. When I enabled that support, and enabled incremental GC (to support the scale of testing I was performing), the performance was similar. This is another example of Rust being mischaracterized up front. Older languages took short cuts, and fare well for the low end of testing (the microbenchmark). Rust tends to look forward and to the bigger picture. Anyway, sorry you deleted your legitimate question. It was a good one, and the kind that will make Rust better.