Slashdot Mirror
Rust 1.0 Released
TopSpin writes: Rust 1.0 has arrived, and release parties in Paris, LA and San Francisco are taking place today. From the Rust Programming Language blog: "The current Rust language is the result of a lot of iteration and experimentation. The process has worked out well for us: Rust today is both simpler and more powerful than we originally thought would be possible. But all that experimentation also made it difficult to maintain projects written in Rust, since the language and standard library were constantly changing. The 1.0 release marks the end of that churn. This release is the official beginning of our commitment to stability, and as such it offers a firm foundation for building applications and libraries. From this point forward, breaking changes are largely out of scope (some minor caveats apply, such as compiler bugs)." You can read about specific changes in the changelog.
Thank you for your interest in joining the Gay Wigger Association of DICE* (GayWAD)! GayWADs worldwide are happy that you'd like to become part of our
constantly enlarging member ship (come sail away 8======D~)
Unlike other geek fraternities that you might have heard about, GayWAD accepts members of all races, creeds, and colors. We don't even have a technical inclination requirement. As our founders stated in the Annals of GayWAD, Chapter 1: "You don't have to be a geek, as long as you like it Greek." They were, of course, referring to the penis in anus style of sexual relations. Don't despair, as attaining full fabulous lifetime status in GayWAD is easy. The only prerequisites for membership in Gay Wigger Association of DICE* are that you meet all of the following conditions:
To submit your Gay Wigger Association of DICE* Membership Application, simply do nothing. Congratulations, you're now a GayWAD!
If you require a specific membership number for purposes such as framing, docking, or prestigious inclusion upon your business cards and resume, please take down this number: 69.
Optionally, you may complete the following survey by replying to this post, indicating affirmative responses with an X in each appropriate box:
GayWAD Membership Survey (OPTIONAL)
[ ] I am gay
[ ] I am a wigger
[ ] I have used SLASHDOT VIDEO to find a sex partner
After completion of this optional survey, your Slashdot post ID shall serve as your unique Gay Wigger Association of DICE* membership ID.
Your GayWAD membership kit** is on its way.
* GayWAD is neither affiliated with nor endorsed by DICE.COM.
** GayWAD membership kit no longer includes HIV self-test catheter.
Running out of words to call those next big things?
And the 3 users outside of Mozilla must be excited.
Apparently not that RUST.
So why should I use Rust instead of the languages I'm currently using (Ada and Racket)?
From the headline, I thought it was Rust the game.... Then I thought, typical of /. to be way behind on a story as Rust the game hit 1.0 a while ago. If you haven't played Rust (the game) it is way more fun then Rust the language.
Mozilla tries to reinvent a bicycle
Rust is old and creaky. Now introducing Shiny! It is the programming language that gets rid of all cruft of Rust and adds a layer of NICKEL (Non-Intrusive Code Keying for Easy Learning) to make your programs shine forever. It is a high level language that anyone can learn to code in, but brings almost assembly level of performance.
Get Started Coding Today!
https://www.youtube.com/watch?...
Microsoft, Apple, Google, Amazon what's the difference? All steal money from devs and control with walled gardens.
Ruby on Rusty Rails?
Sounds like an excellent usage of engineering time. Reinvent the Wheel, make it square this time though!
I've very worried about what I'm seeing with Rust.
The Rust web site says very clearly
Yet when I look at the GitHub issues list for the Rust compiler and standard library, both of which make extensive use of Rust, I see over 1900 open issues and over 11500 closed ones.
When I look at the GitHub issues list for Servo, which also makes extensive use of Rust, I see over 800 open issues and over 1500 closed issues.
The Rust compiler and standard library are being created by the people who know Rust the best. Some of these people are also involved with Servo. Both are the largest real-world Rust projects I know of, too.
If Rust is allegedly so much safer to use, why do projects developed using it, written by some of the best Rust experts around, have so many bugs? If those who know the language inside and out can't write code that's any less buggy than code written in other languages, how are the rest of us normal programmers supposed to ever write good code in Rust?
I'm worried because Rust is going to give a false sense of security and quality to too many people. They'll think that by using Rust they'll avoid bugs, when as existing large projects developed in Rust by Rust experts clearly show, that just isn't the case. For a language that's supposed to make creating buggy code harder, Rust isn't doing a good job at all at preventing bugs.
Rust would have been useful 5 years ago. But now there is no reason to use it. Go, C++14, Ada 2012, OCaml, D, Scala, and even C# (now that core .NET code has been opened sourced and ported to non-Windows systems) offer everything Rust does, plus more. Somebody will probably claim that Rust "isn't competing with those languages", but in reality it is, and it's way behind them. Rust could have been a game changer, but like Perl 6 its developers just couldn't get a stable major release out on a reasonable schedule. Too many years went by and the alternatives became better options.
Job postings for Rust on Dice will require five years of experience for a programming language that came out six months ago.
They could have made the same simple concepts without going C++ style. This is obviously just aesthetics, but I don't think the language looks nice compared to lots of newer languages (Swift, Ruby, Kotlin, and even D).
The :: scope operator is ugly and redundant.
This match syntax is just ugly and hard to type:
match header[0] {
1 => Ok(Version::Version1),
2 => Ok(Version::Version2),
_ => Err(ParseError::InvalidVersion)
}
The following is ugly and is not obvious:
use std::sync::{Arc, Mutex};
use std::thread;
use std::sync::mpsc;
fn main() {
let data = Arc::new(Mutex::new(0u32));
let (tx, rx) = mpsc::channel();
for _ in 0..10 {
let (data, tx) = (data.clone(), tx.clone());
thread::spawn(move || {
let mut data = data.lock().unwrap();
*data += 1;
tx.send(());
});
}
for _ in 0..10 {
rx.recv();
}
}
A simple printf function has to be a macro, because the techniques it uses are unsafe which is a main feature of the language.
OK a lot of these gripes are trivial; I guess I'm getting at the fact that they went an academic route about how to deal with pointers and memory allocation safely, and then built everything around that. It was so academic and engineering-like and they didn't think or try very hard about the design and aesthetics.
Just because the U.S. is a republic does not mean it is not a democracy. Democracy/republic are not mutually exclusive.
Comment removed based on user account deletion
But when I see years of experience in a job posting it usually is like this:
X years of experience in backend/functional programming/frontend/relational databases like (java/ruby/C#)/(clojure,erlang,scala)/(javascript,html,css)/(oracle,sql server,mysql). Bonus points if you have experience with Y technology.
Which is sensible, even though rust might be only a couple of years old when you want a senior dev you want one that has been dealing with these kinds of problems for many years, even if most of those years were not in the right language. So expect a rust ad to say:
10 years with a low-level programming language (Rust/C/C++/Assembly), bonus points if experienced with Rust.
So, is that like a Python or D commitment to stability, or a C/C++ level commitment to stability? Exactly how committed are they to preserving to preserving backwards compatibility through hell and high water? Because that's why people trust C/C++ - they know that the language committees are not going to suddenly "fix" the language by making billions of lines of code obsolete, simply because it was written fifteen years ago before a bunch of new shiny features have been added.
I think widespread adoption is going to remain limited until it becomes clear how Mozilla plans to shepherd and develop this language as well. Will it become standardized? Will mature cross-platform tools become available? What will the performance penalties be to optimized C or C++ code?
I wish Rust all the best. It's going to be difficult to unseat C/C++ simply due to inertia, as well as convincing programmers of the merits of an entirely new language, but I like the idea of a memory-safe language that doesn't require a runtime or use managed memory.
Irony: Agile development has too much intertia to be abandoned now.
They're already beginning to at least replace some components in Firefox with Rust ones, and they have another entire browser they're slowly writing in Rust (although some components are still in C++).
I think at this point, you either stick with what you know, go for the new language that you feel has the most momentum in your field/market, or pick the one that you feel will help you the most and try to see if it will. Waiting for adoption is just an excuse to not be an adopter yourself. If Rust interests you, be an adopter if you can. It's not like it has the support of a Google or Apple behind it, making it a big part of their ecosytems as quickly as possible. It needs interested parties to do their part, too.
When you have a release party and no reference implementation (i.e. hardware HAL to UI).... language isn't going to gain much attention in a few months.
How to tell if you're out hipster-ing your trendy, Brogrammer self:
Your next-big-thing programming language is having simultaneous release parties Paris, LA and San Francisco.
Hire a Linux system administrator, systems engineer,
You can do whatever you want with pointers (although the things that are UB in C will tend to be UB in Rust also), you just need to do so in an unsafe{ .. } block. The improvement over C/C++ is that you won't trigger UB by accident while using the safe subset of the language, and the vast majority of the time you will be able to do what you want in that subset.
Waiting for adoption is just an excuse to not be an adopter yourself.
No, it's waiting for Mozilla to actually prove the language is viable.
Same here. And really, most pointer vulnerabilities go away when you code carefully, and finding the rest with things like Valgrind works well if you actually have thought about testing when you designed your code. And in really critical places, you can always do check-before-use and fail gracefully instead of insecure. Of course, all these things require that you know what you do. Things like Rust are an insult to those of us that do.
Most ACs are not even worth the keystrokes to insult them. Be generically insulted by this and ignored otherwise.
The improvement over C/C++ is that you won't trigger UB by accident while using the safe subset of the language, and the vast majority of the time you will be able to do what you want in that subset.
I can do the same thing in C++ using a safe subset of it as well without needing to learn a new language and waste man years porting software. No one doing modern C++ should be dealing with raw pointers outside of exceptional cases.
Plus, they have yet to even prove the fact that Rust is good at what they claim it's made for. C and C++ didn't win over programmers through hype. They won over programmers by being proven through real-world applications. It's easy to talk up a language, it's much harder to back that talk up with real-world results.
It looks interesting, but they need to work on their documentation. I wasn't able to find anything about reading and writing random access files. It had many things that appear easy to do in Rust which are difficult in various different languages, but I couldn't find a way in which it was notably better overall in any area.
FWIW I was mainly comparing it against D and Python, with a few considerations of Ruby. I should have compared it against Ada, but it's been too long since I actually used it. I can't reasonably compare it against C++ as I haven't used it significantly since the STL was adopted. (At that point I was stuck using access basic, and relatively to that nearly *anything* looks good.) The only fortran I could compare it against is FORTRAN IV, and they are nearly disjoint in the tasks that they would be good at.
Mind you, this comparison is based purely on reading over the documentation, and shouldn't be taken too seriously. So often the contents of the package doesn't match what it says on the packaging. Given what it says on the packaging my favorite language would be Vala, but actually I never use it.
I think we've pushed this "anyone can grow up to be president" thing too far.
The more the compiler can protect me from past-me, the better. And certainly from my coworkers.
Look, I don't get how Rust deals with circular references at all (screw you, leak, I think). But the way to train better coders is to get them up on standards. Why you wouldn't want those standards enforced by the compiler I have no idea.
I read the Rust documentation (what 1/2 or 1/4 or something of it there was). Okay ideas, but not terribly interesting. But if I could snap my fingers and code that didn't meet the coding standard I used wouldn't compile. That would be amazing.
Your ad here. Ask me how!
Why you wouldn't want those standards enforced by the compiler I have no idea.
This reeks of strawman. GP never said or implied any such thing.
Do those smart pointers also solve iterator invalidation? :)
Never claimed smart pointers solve all problems because that would be ridiculous. If you have cases that a smart pointer doesn't solve then clearly you would need to use the correct solution. But for the vast majority of cases that people use raw pointers for, they can be substituted with something safer and remove a whole host of potential bugs from their code.
"Assemblers are an insult to those of us that know what we're doing."
"High level languages like Fortran and C are an insult to those of us that know what we're doing."
"High level scripting languages like Bash are an insult to those of us that know what we're doing."
"High level languages Java are an insult to those of us that know what we're doing."
You stupid fucking cunt, you idiot. Whoever told you that you could speak among men? Get back to gargling your's dog's balls, you useless waste of space.
There is no useful subset of C++ that is a) statically checkable and b) guarantees absence of dangling pointers and null dereferences.
Your point? That other people say things that _sound_ like what I said does not invalidate my point in the least.
Most ACs are not even worth the keystrokes to insult them. Be generically insulted by this and ignored otherwise.
Indeed. And I have the impression that Rust is not nearly that good, and hence an intense marketing campaign is done.
Most ACs are not even worth the keystrokes to insult them. Be generically insulted by this and ignored otherwise.
It certainly is implied that he is against creating languages that enforce certain standards. Note, almost all standards include "Thou shall not"'s for some language features. You practically have to in C++. I mean, I don't know any (modern) standard that would let you pass and cast tons of void*'s around as the standard case.
Your ad here. Ask me how!