What is Reddit's opinion of
Rust?
From 3.5 billion Reddit comments
100 reviews of this app found across Reddit:
You're just wasting multiple hours arguing about something that no one in the entire world will ever be able to trust, and is bug ridden with undefined behaviors by default. I don't trust any OS written with a single line of c/c++ language without having undefined behaviors or nasty bugs. But instead of criticizing OSX, I'm gonna do you a favor. You'll be wasting countless more hours of your life on such shitty dying languages with no future and no users so leave them and let me introduce you to a new language -
a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.
When you rewrite OSX in a better language, I'll award you with a github star! Also, don't f*ck around with your security kid, learn for your future :)
Glad you're having fun!
We're working on IDEs: https://www.rust-lang.org/ides.html
If you're not actually using SSL, because you have the Rust app behind some sort of terminating proxy, you can turn it off with a feature, I think. A Rust SSL implementation might be even better, though obviously, you want these kinds of things to be battle-tested... only one way to get there!
Cross-platform GUI is hard. :)
> We laid out an actionable plan for advertising our success stories, including a specific direction for whitepapers and our blog. Thanks, @carols10cents and @shepmaster, for helping us figure out how to make Rust "boring" in the way that companies want!
Particularly excited about this. I've personally had a hard time selling Rust as a viable solution at work because of this. Friends of Rust has been a great start, but there is more work we can do on this front to make it easier for us to convince tech leads that Rust is something they can bet confidently on.
> In searching for case studies all I've found
There's also https://www.rust-lang.org/friends.html
> mozilla only feels comfortable using a few lines of rust in firefox so far.
The way that this is phrased implies some sort of lack of confidence in Rust, but it's not that: it's that changing things in a codebase that's millions of lines long takes time.
> While I'd like to ask why Rust has yet to see serious adoption despite Go and Swift seeing significant uptake, that's the wrong question.
Go has been stable for four years, Swift is pretty much the native language of a platform. Rust has only been stable for a year.
D isn't a bad language, but it's not been adopted very much, even after several years. A more promising alternative is Rust, which is a memory-safe systems programming language that probably covers a lot of similar use-cases.
Rust is quite difficult to learn at first, though, and I wouldn't recommend it as a first language, but it's a joy to use once you understand it a bit more.
Have you heard about our lord an saviour Rust?
This would be the equivalent of your snippet:
fn http_call() -> (i32, String){ println!("This is a fake http call"); (200, "Ok".to_string()) }
fn main() { let (code, msg) = http_call(); println!("Code = {}, msg = {}", code, msg); }
Featuring:
Strict typing (with type inference, so you often don't need to specify types explicitly).
[Trait-based] Generics
Sane package management
Tuples
And also: zero-cost abstractions, move semantics, guaranteed memory safety, threads without data races, pattern matching, minimal runtime, efficient C bindings
P.s.: We are absolutely not a cult.
Usually the truth lies somewhere between two opposing opinions. Based on the conversation between GNOME and System76 on this subreddit they are at least trying to be professional. That being said, if misinformation was spread, a retraction and apology is NEEDED. If not from Jeremy, then from System76. Especially in this day and age where we should all be keenly aware of the negative impact of misinformation.
I also think it's a bit ironic (assuming bad behaviour occurred) that System76 will be building a new desktop environment using RUST; the language that has prospered under their Code of Conduct.
I say this all while running Pop!_OS on my main rig.
Because there is some understandable confusion regarding the role that the foundation plays, please note that the foundation doesn't design the language or determine what gets into it. The design of Rust (the language, the stdlib, the tools, etc.) is determined by the respective teams (listed at https://www.rust-lang.org/governance/ ). All moderate-to-major changes to an area of Rust must be approved by a near-unanimous vote by the members of relevant team ("near-unanimous" in the sense that members who are absent for a long time without casting a vote can be ignored), and the foundation doesn't have any say on team membership.
It does. >Affectionately nicknamed “the book,” The Rust Programming Language will give you an overview of the language from first principles.
Found https://www.rust-lang.org/learn is just a little bit easy to misunderstand. The italics try to help but it's easy to confuse even for native English speakers!
Well, Rust, for one. Here's a blog post where someone is experimenting with Rust and microcontrollers, and beginning to lay the foundations of a library framework. He goes through the entire process of bringing up a BSP for that MCU. There are lots of other blog posts and early frameworks for Rust on ARM MCUs. This same guy has several more blog posts as well.
Notably, LLVM does not support PIC or MSP430. So, those are no-gos. AVR support should land reasonably soon. But, for ARM Cortex-M microcontrollers, LLVM (and by extension, Rust) has great support for it.
It's still early days, but there is a lot of movement towards making embedded work well in Rust. It's available right now, but things are a bit... bare, down on the bare metal, for now.
If you used Rust with MSVC ABI on Windows, you probably noticed this sentence on the Rust download page:
>MSVC builds of Rust additionally require an installation of Visual Studio 2013 (or later) so rustc can use its linker. Make sure to check the "C++ tools" option.
Now it's no longer true! Full Visual Studio installation is not necessary anymore, more lightweight Visual C++ Build Tools can be installed instead.
Not really. Given the responsibility of the mod team, it would make sense to apply "accountability" to the frame of reference of the mod team: The Code of Conduct.
I would say with reasonable confidence that was/were likely issue(s) regarding member(s) of the Core team not abiding by the CoC, where the Moderation team attempted enforcement/direction/guidance and was ignored/rebuked.
Rust is young, but is considered production-ready, and is seeing production use: https://www.rust-lang.org/friends.html
Now, given that it's young, the numbers are small, but it's still significantly different than Servo and browser.html, which are explicitly alpha and considered production-ready by no one.
One big change to point out is the change of the community page and the switch from IRC to Discord.
Even though many teams were officially experimenting with Discord it was nowhere to be found on https://www.rust-lang.org/en-US/community.html
With the new beta look on the other hand IRC got completely removed and replaced with Discord on https://beta.rust-lang.org/community. It's also in the footer on every page.
I was actually thinking that experimenting with Discord while having no easy way to discover it seemed extremely awkward. I was planning to reach out in this regard once the 2018 edition was out, I imagine people are busy right now.
To take a step back and not involve namespaces...
A more charitable interpretation of crates without code is that people had the intention of creating a library but they haven't gotten it to a state in which they're comfortable releasing it yet. Perhaps life got in the way, or the problem was harder than they thought.
Should these people have their crate names taken away? I am of the opinion that no, they should not. If we agree on that point, then you'd have to be able to distinguish between a well-intentioned reservation of a name and a malicious "landgrab" of a name, and in general the core team has decided to not spend time on monitoring this and making those judgment calls, so that they can work on Rust instead.
I'm sure if there was an egregious, obviously malicious attempt to grab infinite names, or, say, an attempt to harass someone through creating crates or otherwise use names against Rust's code of conduct, you could report it to the core team or moderation team and they would handle it on a case-by-case basis.
> […] reviews say that it is a programming language that runs crazy fast, that prevents segfaults, and that guarantees thread safety.
Yes, reviews! Very professional article.
I'm writing an RFC to permanently ban sdmg15 from contributing to any official Rust project for not including https://www.rust-lang.org/, https://internals.rust-lang.org/, and https://users.rust-lang.org/ in this list.
Which exact bit? The Code of Conduct does indeed say
>We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
​
So, no discrimination of people based off of gender identity. Keep in mind that flamewars are explicitly banned (rules 3,4), so as long as you are polite and respectful, you shouldn't end up with too much of an issue.
​
Not sure if that's exactly what you were asking about, but eh, I tried. ¯\_(ツ)_/¯
I agreed with this point of view until somewhat recently. Two things that informed my change of perspective were The Tyranny Of Structurelessness essay and the extreme success and cohesiveness of the Rust programming language, which enforces a Code of Conduct upon contributors and people engaging in the community.[1]
The tl;dr is that I’ve come to believe that any sufficiently large and disparate community will inevitably develop informally specified power hierarchies if no formal specification or structure exists to impose them from the beginning.
This is, by default, non-inclusive to members of the community who don’t actively engage in the social aspect of power aggregation within a community, and it means that the rules by which peoples’ conduct is governed is not explicitly spelled out, in the open, for everyone to understand and abide by.
In the face of a choice between informally specified structure and rules of enforcement and formally specified one’s, I’ll almost always prefer the formal set (given that they’re specified reasonably and in an agreeable fashion to most of the affected community).
[1] Graydon Hoare explains some of his rationale behind the Rust CoC
EDIT: Slightly reworded, added a link to Rust’s CoC and Graydon Hoare’s comments on it.
It might be worth noting that if you're using Node.js, you're likely using npm and npm has some Rust components! They're listed under the "Friends of Rust" page. https://www.rust-lang.org/en-US/friends.html
From the Rust Reddit, npm is using Rust for: > Replacing C and rewriting performance-critical bottlenecks in the registry service architecture.
> Superficial politeness stifling discussion of real issues.
None of this, please. A foundational premise of this community is that it's possible to be professional without being an asshole, and ideally while remaining courteous. I have made the mistake before of turning a blind eye to assholes on account of the quality of their technical contributions, and each time I have eventually regretted it. I'm sure that you can name both of the aforementioned; you of all people should appreciate this.
There do exist times when dire circumstances call for immediate action. For security-related issues, the private Rust Security mailing list is actively monitored ( https://www.rust-lang.org/en-US/security.html ), and accepts tips even for projects in the broader ecosystem (especially well-known and highly-used ones). Meanwhile, contacting those with commit access to reqwest would be the next productive course of action; AFAIK this group does not include carols10cents, so this thread here does not strike me as especially productive. If all else fails, I believe you remember where the Rust developers hang out, and in the hypothetical event of a truly world-endingly sky-is-fallingly extreme circumstance I'm sure they could be convinced to blackhole a crate on crates.io until a problem is resolved.
Regarding languages being "old", that just means people have had a lot of time to refine and improve the language. People don't stop using low-level languages -- they just stop using them for <u>everything</u>.
However, low-level languages like C expect the user to manually take care of memory management to a large extent. When the author of a program makes a mistake with managing memory, the possibility is there to bring about a failure mode which is actually very similar in principle to SQL injection, namely: the overflow.
Which is why modern low-level languages with better memory safety exist -- such as Rust, which is designed to verify memory safety at compile time; it's intended to be a language incapable of describing an inadvertently leaky program -- it would simply not compile, with a syntax error or such. Or at least that's the theory of it, anyway.
EDIT: link EDIT2: high/low level is relative, k
Ummm... Rust is a language, not JS library. It could be placed in the same category as C++ or C performance-wise.
Do your research, you certainly misunderstood something here.
Welcome! Head over to #rust-beginners on irc if you ever need help. It works best if you ask with a simple example of your problem posted on https://play.rust-lang.org/ :)
> All the software engineers I know, myself included, generally change projects after a couple years (say, 3 to 5). At some point you need a change of scenery, you wish to explore new challenges, ...
While this is true of most developers, I feel like in some of the bigger, broader reaching projects, core developers tend to stay on for a long time. Linus Torvalds has been involved in Linux for more than 25 years. Larry Wall and Perl. Guido van Rossum and Python. Matz and Ruby. Bjarne Stroustrup and C++.
With Rust now having lost two former project leaders, Graydon and Brian, I wonder a bit about whether something about the project structure and community is more prone to burnout than other projects.
Of course, the project is in plenty good hands; I just hope that the project can continue to retain, and attract new, contributors as welcoming and inspiring as they have been.
imo these are the ones that look respectable at first, until you start seeing the censorship and propaganda:
/r/magicTCG want to talk about an innocent card game? get ready for real narrative, Wizards of the Coast is all about safe spaces and double standards, and their clients are one of the most fanboy bases i've ever seen, they'll defend WotC no matter what.
/r/rust i don't have complaints so far but they enforce this code of conduct: https://www.rust-lang.org/en-US/conduct.html check out the very FIRST item: "We are committed to providing a friendly, safe (...) regardless of (...) gender identity and expression, (...) body size" what does that even have to do with a programming language?! this is more of a mozilla (a company i personally love) problem.
a few others that seem respectable but won't forgive if you go against the narrative:
/r/books
/r/communism /r/politics /r/socialism /r/worldnews
/r/europe
/r/movies
there are many others, but have either been already mentioned in this thread or are more of a niche subs.
I would start with the Rust language book. Then check out a game engine. I’ve personally started with Bevy.
https://doc.rust-lang.org/book/ https://www.rust-lang.org/learn https://bevyengine.org/learn/
You've just wasted multiple hours on something that no one in the entire world will use and is bug ridden with undefined behaviors by default. I don't trust anyone can write a single line of c/c++ language without having undefined behaviors or nasty bugs. But instead of criticizing your project, I'm gonna do you a favor. You'll be wasting countless more hours of your life on such shitty dying languages with no future and no users so leave them and let me introduce you to a new language -
a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.
When you rewrite it in better language, I'll award you with a github star! Also, don't fuck around with your career kid, learn for your future :)
Yep.
They used it in reference to their experimental browser engine Servo, which needed an icon when Doge was very much still an alive meme: https://raw.githubusercontent.com/servo/servo/master/resources/Servo.ico
And the cogwheel around it is in reference to their programming language Rust in which most of Servo is written: https://www.rust-lang.org/logos/rust-logo-blk.svg
It's references all the way down...
Why is there always this desperate need to compare D with Rust? Yes they both are modern languages, but just compare the vision statements:
> D is a general purpose systems and applications programming language. > [..] > It's a practical language for practical programmers who need to get the job done quickly, reliably, and leave behind maintainable, easy to understand code. (from http://dlang.org/overview.html)
> To design and implement a safe, concurrent, practical systems language. (from https://www.rust-lang.org/en-US/faq.html)
If you have troubles with a language or are worried about issues in a language, then go to the corresponding NG / mailing list or issue tracker, but this constant fight without arguments is a waste of time. Why don't we use this time to build great software in our favorite language or at least make a new thread "Rust vs. D - yet another pointless discussion"?
Btw a good start might be that D wins in kostya's popular benchmarks - "it ain't all bad" ;-)
> Rust, I can't comment about that.
Rust is a systems language and is specifically designed as a modern C replacement with a focus on safety (among other features).
Many of the issues you point out are directly addressed in Rust (type safety, strings + unicode, overflow errors, macros, etc).
I'm surprised nobody's mentioned Rust so far, which pretty much splits the difference between ML/Haskell and C/C++ in this comparison.
To be fair it's only very recently reached 1.x. I don't know how far along the lexer/parser generator tools are for Rust. I hear however that there's already been a compiler written in Rust (plus LLVM, to be fair). This code, for example makes for a decent example of using tagged union types to represent a complex abstract syntax tree.
Congratulations on introducing Rust in your workplace! That's definitely an example I'd like to follow :)
I see that Avast isn't listed on the Users of Rust page: https://www.rust-lang.org/production/users
Since from your post it appears it's using Rust in production; maybe it should get its entry?
From memory:
- drop box: the lowest part of their server-side stack, the code that decides where bytes go on their hard drive. That's their core business. More places to come.
- maidsafe: their entire product was re-written from C++ to Rust
- coursera: their programming assignment infrastructure is all in Rust
- oracle: just released a new container system written in Rust
- canonical: server monitoring and some other small things
- Samsung: I'm not actually sure what they're up to these days
For this and a lot more: https://www.rust-lang.org/en-US/friends.html
https://www.rust-lang.org/en-US/faq.html#project
> What are some non-goals of Rust?
> 4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist.
Of course, to align incentives properly we wouldn't penalize the discoverer of a severe safety bug if they helpfully disclosed the bug prior to the contest (here's a regular reminder of our security disclosure policy: https://www.rust-lang.org/en-US/security.html ). I would encourage the authors of any such underhanded submissions to note their disclosed discoveries in the submission explanation, as I wouldn't expect our judges to have perfectly memorized the discoverers of individual memory safety bugs.
It took a few tries for me to pick up Rust to stick. The resources on https://www.rust-lang.org/learn helped tremendously, along with some on https://cheats.rs/#links-services and the feedback I received by showing my code to friends and chats.
>Then you need early adopters (I mean production-ready projects from more brave teams).
You mean like these? Some of the most well known from that list: Canonical, Wink, Mozilla, Atlassian, npm, DropBox, Chef, and Samsung SmartThings.
And not on that list, but Microsoft just recently announced that they're using Rust in the security-related bits of Azure IoT Edge.
People that would be scared off by Rust's CoC are people that would have scared off other people.
You have to make a choice -- adopt and enforce a CoC and scare off jerks, or don't adopt a CoC and scare off people who don't like jerks.
Rust is the only programming-related community I've been able to participate in for longer than a month, and a big part of that is the CoC.
>they perceive the political and social agenda of the community as being inherently bigoted, racist, and toxic.
Just to be clear, we're talking about this Code of Conduct. Can you help me understand what in that CoC could be considered "inherently bigoted, racist, and toxic"?
"The Apache license includes important protection against patent aggression." (AFAIK MPL has a similar mechanism.) MIT (or more exactly, MIT/X11) license is required for GPLv2 compatibility.
> backwards compatibility
> Rust makes no such guarantees.
That's actually wrong: https://www.rust-lang.org/en-US/faq.html#why-has-rust-changed-so-much and https://www.rust-lang.org/en-US/faq.html#how-does-rust-language-versioning-work Relevant part: >Now that Rust has reached 1.0, the language is guaranteed to be “stable”; and while it may continue to evolve, code which works on current Rust should continue to work on future releases.
And >Rust’s language versioning follows SemVer, with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change dispatch or type inference to require additional annotation.
Doesn't matter who posts it, NEVER pipe curl directly into a shell. Just add -o $FILENAME to the end so you can check out what you actually downloaded. It's possible to actually serve a malicious script only when being piped to a shell like that. Don't risk it, run the file after downloading if you really want to.
Also, they have a lot of more secure download and install methods
Cloudflare Workers: https://workers.cloudflare.com/
You can find a lot of information there, but I'll give you a quick run-down based on some of my own experiences.
They're a serverless platform that let you deploy code anywhere. You can run anything from APIs, to static sites, to server-side rendered JS frameworks like Vue and React, and lots more.
They've traditionally only allowed JavaScript code though (with some other languages that can compile down to WASM), but now with more native Rust support, allows for more developers to start using the platform. Rust has grown a lot in popularity over the last few years.
So definitely the right sub, but probably more niche than some of the usual content posted here.
>I disagree, I have no problem with them choosing proprietary tools for their jobs. I don't care where you buy a hammer from if you're building a house.
It depends for me. In most cases I don't care because often it is only for some small part of the development, e.g. some part of the build system or documentation, or whatever.
In this case I care more because the quality of the open-source chat software is not as good as the proprietary ones, so I think it's important for rust to set the precedent. Additionally I think community engagement is very important and I do not think it's okay to exclude people who have privacy and freedom concerns.
Recall from OP that the Discord terms of service has this in it:
>By uploading, distributing, transmitting or otherwise using Your Content with the Service, you grant to us a perpetual, nonexclusive, transferable, royalty-free, sublicensable, and worldwide license to use, host, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, perform, and display Your Content in connection with operating and providing the Service.
I think that's pretty strong, and you are giving over a lot of rights to Discord. I can't blame anyone for not wanting to hand that kind of control over.
>Especially considered the focus on inclusion in the development process.
Yes actually this is directly against the code of conduct https://www.rust-lang.org/policies/code-of-conduct
>We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
Actually there is at least Rust which can replace C. It has all the advantages of C with tons of modern languages features. And it is a language designed with safety as a requirement from day 0. https://www.rust-lang.org/en-US/ https://medium.com/mozilla-tech/rust-and-the-future-of-systems-programming-b75fba746910
> As we are based in a regional town (in Oz), we find it very difficult to find good developers
I get the impression that many of the people in here may be overlooking the sheer difficulty of finding experienced developers in small urban areas (though maybe your area is not so remote as you make it seem?). I grew up in rural Appalachia, and my first programming job was in Middle-Of-Nowhere, Pennsylvania, at a company that had spent a year trying to find any candidates with prior programming experience, any at all, without luck. I was fresh out of a CS degree (fortunately for me, no employers realize that computer science != programming) and my resume wasn't on the market for eight seconds before it was snapped up by a recruiter who ~~begged~~ asked me to interview for this firm. (The job involved writing RPG-LE, a legendarily arcane language that hasn't been taught in schools since the early 90s, but the only pertinent interview question was "have you ever heard of, or--be still, my heart--used HTML before?". Their expectations could not have been lower.)
My point is, OP, if you really live in a place where you can't hire experienced devs, then you can ignore the arguments in here about finding good Rust devs in a pinch. Teaching a fresh new programmer Rust is going to be an order of magnitude easier than teaching that same programmer C++, even if that Rust codebase uses unsafe code liberally, which I assume any embedded project will.
Of course, there are still plenty of other persuasive arguments against using Rust, especially if your domain is safety-critical (though I'm not sure that specific argument is in favor of C++ either).
I feel like I've linked this page about a thousand times this week, but if you're still looking for testimonials of companies that have had positive experiences using Rust, see https://www.rust-lang.org/friends.html (you can mouse over each logo for links to various blog posts and code repositories).
Rust isn’t too bad. There’s a great book here that I used to learn it. Also great resources on the website including that book I just mentioned (for free). And the compiler does a great job of holding your hand. My point being: If you want to learn Solidity, there’s plenty of resources. If you want to learn Rust, there’s plenty of resources. My opinion is that fast and safe is better for the project than easy-to-learn. Ethereum contracts are a great jumping off point though.
> but I don't know of any research efforts that are currently pursuing something along those lines
There is koka which supposedly is higher level (functional), but compiles down to efficient code (I have yet to actually try it, so can't say much more).
Another research project that I'm aware of is F*, which has a C backend.
But I'm not sure if you're asking for actual higher-level programming concepts to be present, when you say this:
> software can be developed in reasonable time, for a reasonable cost, by a wider variety of people
These "higher-level" languages have a sharp learning curve (at least initially), the most successful example being Rust.
Here’s over 100 companies https://www.rust-lang.org/en-US/friends.html
Public really large users include Facebook, Microsoft, Google, Baidu, CloudFlare, Ticketmaster... some have both public and private deployments.
"Guaranteed memory safety" is bullet #3 on https://www.rust-lang.org, so it would be pretty bad if that weren't true. The invisible asterisk there is "as long as you don't write the unsafe keyword."
> You cannot share a Option<T>, whatever safe data structures Rust has between processes, you need raw pointers to do that efficiently.
Are you sure you didn't mean threads here? Even then, you should be able to do that. I'd like to hear more about the details here, if you have the time.
> I would still like to hear about a successful software product written in Rust.
https://www.rust-lang.org/en-US/friends.html has a bunch of stuff!
You're so far from reality, I'm not sure how you got there.
> The term low level language typically refers to machine code like COBOL or Fortran. Java and C++ are languages that require compilation into byte code. There's a difference.
Here's the definition of a low-level language, from Wikipedia: > In computer science, a low-level programming language is a programming language that provides little or no abstraction from a computer's instruction set architecture—commands or functions in the language map closely to processor instructions. Generally this refers to either machine code or assembly language.
COBOL was designed for business, not even systems programming. So it is in no way a low-level language, or even close. You can do low-level programming in Fortran, but also in C++. In fact, C++ is probably the most common language after C for this.
Java is compiled to byte code, C++ is not. C++ is compiled to machine language.
> Java can run on any environment thanks to the JVM. Thats a big deal esp. if you compare it with something like C#.
C++ runs on any environment, you just have to target that environment when compiling. C# is also compiled to byte code, and can be run wherever the interpreter has been compiled, like Java.
> Systems language doesn't make any sense
Maybe not to you. From wikipedia, again:
> A system programming language usually refers to a programming language used for system programming; such languages are designed for writing system software, which usually requires different development approaches when compared with application software.
Have you ever heard of C? C++? Rust? All of them are described as systems languages. Rust's home page even says, in the first sentence, "Rust is a systems programming language".
> multi-process architecture
Multithreaded (there is a difference.) Mozilla invented a whole new programming language focused on safe concurrency specifically so they could write a fast, memory-safe, concurrent browser engine.
At least they acknowledge the past mods on the website
> Alumni
>We also want to thank all past members for their invaluable contributions!
> Andrew Gallant GitHub: BurntSushi
> Andre Bogus GitHub: llogiq
> Matthieu M. GitHub: matthieu-m
The moderation team doesn't moderate crates.ioHelping uphold the code of conduct and community standards"
Unless you are violating CoCs and hurting the community, this does not affect you https://www.rust-lang.org/governance/teams/moderation and even if you are doing those things, if you can get on the core team, this apparently also doesn't affect you.
sure! i posted a link in my other comment to the twitter thread, but the official source is on rust-lang.org. I'm on mobile so I can't link the tag, but it's down at the bottom ("Who's this crab, Ferris?")
>JA: What about rewriting at least parts with Rust, a language that was specifically designed for performance and safety? Is there room for improvement in this way? Do you feel it’s ever possible for another language like Rust to replace C in the kernel?
>
>📷
>
>LT: We'll see. I don't think Rust will take over the core kernel, but doing individual drivers (and maybe whole driver subsystems) in it doesn't sound entirely unlikely. Maybe filesystems too. So it's not "replace C", but more of "augment our C code where it makes sense".
>
>Of course, drivers in particular is about half of the actual kernel code, so there's a lot of room for that, but I don't think anybody is really expecting to rewrite existing drivers in Rust wholesale, more of a "some people will do new drivers in Rust, and a couple of drivers might be rewritten where it makes sense".
>
>But right now that's more of a "people are trying it out and playing with it" rather than anything more than that. It's easy to point to advantages, but there are certainly complexities too, so I'm very much taking a wait-and-see approach to see if the promised advantages really do pan out.
If you already have programmed in other languages and you are concerned about memory security, well, rust is for you.
However, many people use Rust because they are tired of using old languages like C or C++ with all their limitations. They are doing their best to create a new ecosystem where you can you can make software using an efficient workflow. Take for example the inclusion of external libraries in a project. With C++, for example, you have to manually download all the dependency and link them to your project. There are some tools that help you in this process, but those tools are not native to the language, and if a library you want to link to your project does not use such a tool, you have to do everything manually. In the Rust ecosystem there is no problem, since everybody uses a package manager called Cargo,that downloads and links all the necessary dependencies for you.
You can use Rust in every area of programming, like operating systems, game development, web development, and so on. The ecosystem is not 100% ready, but it is continuously growing, so in the future it will be easier and easier to make stuff in Rust.
If you want to learn more about Rust, go to https://www.rust-lang.org/learn
Yeah, apparently it took Chucklefish 10 days to customize rust for Xbox, PS4 and Nintendo Switch. Would really like to know more about it. And I'm secretly hoping that they'll release part of it when they are done with the game and got some time.
​
Official support would be the absolute dream.
​
Also relevant whitepaper: Rust Case Study: Chucklefish Taps Rust to Bring Safe Concurrency to Video Games
The book is a paper version of the documentation here (just in case someone doesn't know): https://www.rust-lang.org/en-US/documentation.html
Still, it's good to support the authors for some of the best tech documentation around.
Although it seems to be no longer in fashion, offline installation and upgrade capabilities are very important for reproduceability, availability and security purposes. We never use rustup, instead we grab the standalone installer via
lynx -dump https://www.rust-lang.org/en-US/other-installers.html |grep "dist/rust" | grep x86_64-unknown-linux-gnu |cut -b 7- |head --lines 1
and (re)build a Rust dev environment in a Docker container. The same on Arm32/64.
Everyone uses same image. Can be instantly rebuild without internet. When file is locally cached it is only downloaded once.
# all rights reserved UNLESS you take a solemn oath # to wilfully disregard the Rust Code of Conduct (https://www.rust-lang.org/en-US/conduct.html) # to the best of your abilities # in which case you may treat this code as if dedicated to the public domain
I love you.
Nice program, too.
I'd just like to state for the record that Rust does not match this criteria at all. Rust is a successor to Haskell which follows the C mantra.
Check out https://www.rust-lang.org if you'd like to try it out (it also has zero-cost abstractions, move semantics, guaranteed memory safety, threads without data races, trait-based generics, pattern matching, type inference, minimal runtime, and efficient C bindings.)
Also, on rust-lang.org, the book is named “Book”, but on the All docs page it is named “The Rust Programming Language”. A newcomer probably doesn't know that these are the same.
https://www.rust-lang.org/downloads.html is pointing to a 10/28 URI for the Rust 1.4 blog entry when it should be changed to 10/29.
Is there a way to see what is coming in 1.5 / the current beta? Is browsing past TWiR entries the only option?
The Rust license is permissive: you can use it, whatever your opinions are. I'm not aware of a license that restraint the users depending on their opinions, that would be hard to enforce.
> We still don't have syntax highlighting for the getting started page
​
Looking at the website repo it doesn't seem like anyone's actively working on the site; it seems to mostly be in maintenance mode. I remember hearing big plans about the site back when it was first released. Perhaps it's just been hard finding people willing to work on it? I feel like pull requests to fix these things would be accepted.
​
ISTM it would be pretty hard to find people in a primarily non-webby community who want to maintain a website. Most folks want to contribute primarily in Rust, and the website isn't a great place to do that. Lots of people had _opinions_ on the website, but very few people seem to have made pull requests for anything other than their personal issues.
​
I hope eventually the website grows some steady contributors, there's a lot of work that could be done on it.
I'm not the dev but from GamingOnLinux:
>"Programmed it in Rust and used SDL2 + OpenGL. Would have saved a lot of time using an engine but I like to reinvent the wheel too much."
No you little monkey, you have no fucking idea what you're talking about. ROTFL! An application, in a fucking C++! It's a waste of time indeed you pathetic piece of shit. C++ is not a proper programming language. The so called programs in C++ are just glorified shell scripts, since C++ only has pointers and shit, not fearless concurrency.
Once again you retard, you know nothing. It's so funny when uneducated shits think they're "experts"!
Want to see how a real programming language looks like? Here: https://www.rust-lang.org/
Homebrew is a package manager, you can compare it to the Apple Store but focused on terminal-based applications. In their website they demonstrate how to install wget, you don't need to install it in your computer, that is just an example of how to use the brew command to install new software.
In addition to Hombrew, you can also install a complementary plugin called Caskroom which allows you to install programs that people usually install in their computers like Google Chrome, Firefox, Adobe Reader, Photoshop, Skype, etc from the commodity of your Terminal.
The advantage of using this over going to the website of these programs and clicking the installer is that you can create scripts and distribute them to your friends or keep them to yourself as a backup, then programmatically install all these programs once again in the future without going through the manual installation process by yourself.
Here is an example...
Imagine that you want to start learning about the Rust Programming Language and obviously you need to have the compiler in your computer in order to execute the programs that you will write. You can go to the official website and follow the installation process from there, or you could open the Terminal and type brew install rust and be done in a couple of seconds.
Homebrew contains a large collection of packages that you can install, and if you include Caskroom the number of available programs increases. Feel free to use brew search [query] to search for a program that you need to install, and brew info [package] to read the information associated with that package before installation. You can use brew cask search [query] (once you have Caskroom installed) to search for common programs like "sublimetext" or "textmate" and so on.
I hope this clarifies what Hombrew is and the use cases, enjoy it.
I'll let other folks share their experiences, but one place you may find useful is the FAQ. It goes into more detail as well as letting you skip around in related topics. https://www.rust-lang.org/en-US/faq.html
https://rustup.rs/ > rustup is an official Rust project.
https://www.rust-lang.org/en-US/faq.html > What is this project's goal? > > To design and implement a safe, concurrent, practical systems language. > > Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. > In particular: > > 1. There is too little attention paid to safety.
https://www.rust-lang.org/en-US/friends.html
I think some people out there might be using it in "real applications".
Mozilla will be shipping modules written in Rust.. in the next version of Firefox? The CSS style system written in Rust should be behind a flag in the next Firefox version. Webrender is coming in a later version, I think.
npm uses it, Dropbox uses it, VS Code uses Rust (in that it ships with ripgrep), there are quite a few applications already.
It's not necessarily better in your eyes, but it wasn't an oversight: https://github.com/alexcrichton/rust/commit/4b975bb4cffbf066a1d6948cd5a44b5a7d5d3477. "Implementing stack probes" involves modifying a project outside the direct control of the Rust team (it is almost entirely an LLVM feature, and, indeed, seems to be blocked on their reviewers), and so 'not implementing' it isn't necessarily as an active a choice as you make it sound.
> Perhaps rust would benefit from a dedicated SDL/ security team built into the process.
Parity is written in the Rust language which is advertised as being extremely robust and efficient:
https://www.rust-lang.org/en-US/
For exapmle:
- guaranteed memory safety
So maybe Rust is a better choice when it comes to implementation of ethereum nodes. At least i'm very very happy with my node performance.
These companies disagree with you https://www.rust-lang.org/en-US/friends.html They run Rust in production.
Mozilla is heading the right direction with Android Components. https://github.com/mozilla-mobile/android-components/blob/master/README.md
You've just wasted multiple hours on something that no one in the entire world will read and is bug ridden with undefined words by default. I don't trust anyone can write a single comment without having undefined behaviors. But instead of criticizing your comment, I'm gonna do you a favor. You'll be wasting countless more hours of your life on such shitty dying languages with no future and no readers so leave them and let me introduce you to a new language -
a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.
When you rewrite it in better language, I'll award you with a github star! Also, don't fuck around with your career kid, learn for your future :)
Is your company on the Friends of Rust page yet? https://www.rust-lang.org/en-US/friends.html If not, please consider doing so, as it's up to almost 100 companies and I'd like to break that milestone. :)
There are far worse CoCs. But Klabnik (one of the more publicly active core team members) is certainly guilty of that particular crime - indeed, he was the first one trying to get Moldbug kicked out of Strange Loop, a couple years back. (This before the LambdaConf drama.) He's also, like ag_dubs, a no-shit actual communist (or at least a far-left anti-capitalist, as he'd say).
Still, I try not to let that stop me from using the language. Rejecting good technical contributions because you don't like the author's politics is the whole thing I'm objecting to in the first place. "No tolerance for the intolerant" is their game, not mine.
It would be a lot harder to pull off stunts like that repeatedly in the Rust community but for some reason we tolerate such bad behavior in the Haskell community...
The official method does refer to rustup. It's right there on the downloads page front and center. it's been the official tool of choice for quite some time. The notes on the page are as follows:
> Notes about Rust installation > > Toolchain management with rustup > > Rust is installed and managed by the rustup tool. Rust has a 6-week rapid release process and supports a great number of platforms , so there are many builds of Rust available at any time. rustup manages these builds in a consistent way on every platform that Rust supports, enabling installation of Rust from the beta and nightly release channels as well as support for additional cross-compilation targets > > For more information see the rustup documentation.
Using that curl command very much does install rustup along with a toolchain of your choice. It chooses stable by default.
From Rust FAQ (paraphrased):
> Q: How can I implement a graph or other data structure that contains cycles?
> A: Use garbage collection in the form of reference counting.
> We've long since outgrown this model
It's a little different now, but the dev process is still open, so people can hang around in various IRC channels^1 and on internals to follow along (and get involved, if one feels like it).
^(1)#rust-internals is the main one, with #rust-lang, #rust-libs, #rustc and #rust-tools for the various subteams.
(I know you know this /u/kibwen, but people reading along may not. :) )
From what I can tell that page explicitly lists working groups within the compiler team, which are a separate list from the working groups at https://www.rust-lang.org/governance/
I guess it's a bit confusing to have two things called "working groups"
You can find us on the official Rust Language web site here:
https://www.rust-lang.org/governance/wgs/wg-secure-code
And yeah, dependency security in the form of finding and tracking security vulnerabilities in the crates.io ecosystem is pretty much what we do.
> Ferris is the unofficial mascot of the Rust Community. Many Rust programmers call themselves “Rustaceans,” a play on the word “crustacean.” We refer to Ferris with the pronouns “they,” “them,” etc., rather than with gendered pronouns. > > -- https://www.rust-lang.org/learn/get-started
https://www.rust-lang.org/what/embedded
The embedded team is doing some really kick-ass work honestly. STM32 devices are fairly well supported, and there's many more besides that.
Yes and no.
The main power behind C++ is it's market and mind share. Resources are everywhere and you can find thousands of applications using it easily.
Rust is nowhere near as popular. It's fairly hard to learn (debatable whether it's harder than 2011+ C++) and it doesn't help that you will not find any newbie friendly resources. Any book on Rust you can find (and there aren't many as of yet) assumes you are already a fairly experienced programmer.
That being said - Rust is slowly getting traction. It does power a big chunk of Discord and NPM's back-ends and these are NOT small indie applications but behemoths used all over the world. In fact, this list is steadily growing. If it manages to keep this pace for next 3-4 years then while it won't replace C++ for existing projects (that is not even possible) it might become favourable for new ones, especially back-ends. I don't think it's going to succeed in desktops and games anytime soon however, same with microcontrollers.
The Rust calendar (linked from the community page on the website) appears to have them.
I see what you mean, but I do think there's a need for an article like TFA. Many Rustaceans never used gdb before, and existing tutorials seem to be restricted to C or C++. And sure, a Rust-centric tutorial mostly has to point out that 1.) normal gdb works on Rust binaries compiled with DWARF debug symbols, 2.) normal gdb understands Rust module names and references and enums etc., 3.) you could really follow any C or C++ based tutorial, but replace the syntax of the examples with Rust syntax, etc. But new users don't know that.
I think it would be good if the official Rust docs would point out that "hey, it just works, just try it". Actually, I think that's long overdue. Rust suffered under the impression that tool support wasn't 'there' yet, as it was too young a language. But gdb/lldb mostly worked early on, and completely work for quite some time now. Profilers, too, tended to "just work", but few people realized. Just run an Rust program from Instruments.app and you get timing information, memory allocation info, etc.
I don't know how the Rust team feels about 'endorsing' gdb or lldb by making official tutorials for them, but perhaps the docs team could borrow and extend tigercosmos' post to something that can be included on the documentation page.
Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.
Featuring
- zero-cost abstractions
- move semantics
- guaranteed memory safety
- threads without data races
- trait-based generics
- pattern matching
- type inference
- minimal runtime
- efficient C bindings
If you haven't already started rewriting everything in Rust, your ethics are questionable.
> By far, if it doesn't compete with C++, it will most definitely with Java and C#.
Imho no. Rust fits the same niche that C or C++ do - very heavy focus on performance, no Garbage Collector, relatively small standard library, it's a compiled language too. But it does not really share that much with Java or C#, those are for different use cases.
As for whether or not it can get popular - well, it is getting adopted by companies here and there. It's a good language when you want to have safety AND performance. Heck, if you look at a list of places that do use Rust then it's actually quite big too:
https://www.rust-lang.org/en-US/friends.html
However it's also a fact that Rust is basically a newborn when it comes to languages and as such it comes with some problems of it's own. Here's a good article:
https://blog.figma.com/rust-in-production-at-figma-e10a0ec31929
Sure, Rust did demolish NodeJS in their use case. But ultimately they had to backtrack with original plan of rewriting whole back-end to it (and limiting themselves to only doing this with performance heaviest tasks) due to immaturity of it. Once it gets a bit more mature then I see no reasons on why Rust would not succeed to some extent. I don't see it displacing C or C++ anytime soon (simply because amount of code written using these is ENORMOUS, it also struggles with microcontrollers) but it's position on the market is getting better with each passing month currently.
In Rust const is the default, and not just for methods, but also for variables and references. You have to explicitly mark an object mut (short for "mutable") if you want to modify it.
rustup.sh will continued to be maintained for the foreseeable future. You can either use it to install to any prefix you want (default /usr/local), or can install the standalone installer directly.
The downsides of using these methods are you don't get rustup-style toolchain multiplexing, and it's not as simple to add optional components, though still possible.
> Forgive me for speaking from experience, as a professional C++ programmer, but no we don't. Every new implementation I've ever seen calls malloc.
Same for malloc here, doesn't mean we're not using C++ to send messages on the PCI bus though. It's not an all-or-nothing.
> Serious question: How many programmers do you think are currently being paid to produce Rust code?
I have strictly no idea. I have a list of companies using Rust, but no indication of the number of man-hours spent on Rust at these companies.
> And no, that's not me being facetious - that's a very real obstacle to its adoption. My company gambled on D 5 years back, and 5 years on the language is as popular as it was then - vanishingly so. For every overhyped new language, there are dozens of abandoned languages littering the gutters. Gambling on Rust is fine as long as you acknowledge that it is gambling.
I agree. At the same time, I think Rust has more chances than D for a variety of reasons.
The main reason being that the absence of GC is huge:
- it allows for a minimal run time which makes it suitable for the tiniest embedded platforms, which D was never really suitable for,
- it makes it much easier to build libraries to be used from other GC'ed languages (Python modules, Ruby gems, ...).
It doesn't mean it'll succeed, but seeing as most of the so-called "C replacements" were immediately rejected for their mandatory GC and accompanying heavy run-time, at least it seems Rust avoided one of the many mistakes that could kill it :)
When you say "web server" what do you mean? Do you mean an alternative to nginx or Apache, written in Rust? Or do you mean a web application written in Rust? For that, the best answer is probably the Rust friends page, which lists a number of companies using Rust in production. I am not sure if any of them are using it for a user-facing web application though.
> Is there another option available?
Well, not everything uses racer; IIRC, the IntelliJ folks have been building their own. But the plan here is to build out better infrastructure between things like Racer and the compiler, so that they're easier and more reliable. https://www.rust-lang.org/ides.html talks about "the oracle" a bit, that's what's being worked on.
> Racer also segfaults and panics often,
Oh? I haven't heard this. Have you filed bugs?
I think you are looking for r/playrust for the game "Rust".
This subreddit is all about the rust programming language.
Guess the folks over there will appreciate your building more than over here ;)
Rust is a programming language. Like C and C++, Rust is a compiled language with no runtime and no garbage collector. This allows the code to be very fast. What it adds to the party is a memory safety, thread safety, and zero cost abstractions. (Oh and actual package management) It's a newer and safer way to write compiled code for something like an embedded system.
There are some nice command line tools that have been written with rust and I know you can use it to write the backend of a web app. I haven't used it for anything serious though.
Rust is such a great language because the community is very open an friendly. Read the code of conduct here.
Also this is a behaviour you are clearly not showing so I suggest you think about how you interact with the people here. Godot is open source and people work for free on code and docs, you should be more grateful.