Hacker News Reader

I like Rust a lot. And used it for about half a year in my spare time. But in that time, my impression with it is that it is a VERY hard language to be productive in when its something you rarely use. So I wouldn't mind learning it and using it in my dayjob or if I had more free time. But trying to fit it in between work, family, and leisure time didn't work out so well for me.

Yea, the survey says that IDE support is the third-highest item for increasing adoption (https://blog.rust-lang.org/2020/04/17/Rust-survey-2019.html#...). Rust users would benefit greatly from the Analyzer work that is in flight. Really looking forward to this becoming stable. The tooling it offers is great.

rust-analyzer is stable enough to use, and it's _awesome_.

I wish I had something this slick for Scheme, C, C++ and even C#. Omnisharp is good, but not this good.

VC++ analyser + Intellicode (AI driven intelisense)

C# Roslyn analysers or StyleCop, also on VS.

CheckStyle or PMD for Java, alongside Netbeans, Eclipse or InteliJ.

XCode analysers.

CLion Inspections.

I use omnisharp-roslyn, it's not as good as the rust-analyzer integration to lsp.

It helps that rust has incredible documentation.

So you don't use the real deal (VS), naturally the experience suffers.

I've used it and was non-plussed. I have it installed and find it too brittle to bother with.

Never in my life has Emacs segfaulted or indefinitely suspended. It was nary a day that VS would not do so.

Thing is, Emacs only edits text, even with a ton of Elisp plugins there are plenty of graphical stuff done by IDEs that it will never do.

It as a good workaround for me during the late 90's up to mid-2000 until UNIX finally got proper IDEs.

And yes, I managed to bork it multiple times.

Pffft, my code docs have artist-mode figs in them.

I have used both, and I’ve found rust analyzer to be better but not amazing. It seems it often “gives up” and autocomplete stops working. It is improving over time though.

Even in the past few months alone it feels a lot more reliable.

One of the issues preventing the type inference from working in the presence of associated types was fixed this week, so the next release should be even better.

C complicated? It is a very small, simple language for a system programming one.

C++ complicated compared to Rust? They offer roughly the same features and both are complex languages if you want to understand what is really going on.

Rust is a very good language that competes with C++. The main feature it brings to the table isn't simplicity (Rust, like C++, isn't simple at all), but the borrow checker.

Please avoid making comparisons between languages if you don't know them (as you claim).

>C complicated? It is a very small, simple language

That's a bit misleading though. Yes, C is very small - but that doesn't mean it's magically easy to understand. It's size has a huge consequence; the language doesn't do much for you, so it's up to you to fill in the gaps, e.g. correctly manage memory

I find C much simpler to learn and to write simple things in.

If you learn C, you'll find that most used languages are compatible with C way of thinking. You can pick up C#, Java, Javascript, Python, PHP with ease as you kind of think in the same way.

While Rust, the language might not be terribly complicated, you have a totally different paradigm, the restriction on variables and the borrowing system makes it totally different than the languages people are used to, to the point that for beginners is totally unintuitive.

You can't just declare a variable, initialize it, pass it to a function and get a result back.

You can't have self references in a structure.

No, siree, as a beginner learning Rust you have to do a lot of complicated dancing around the borrow checker.

Comming from C like languages I find even functional languages like F# easier to pick up. Because they feel more intuitive. Unlike Rust you kind of feel what kind of code you need to write to get a workable result.

Right now I feel that the only advantage of Rust over other safe by default languages is speed. You can use low level constructs and unsafe features like raw pointers in C#, but the garbage collector for the safe code slows it down.

I don't think garbage collected languages can ever be as fast as Rust.

Reference counting like in Swift is another way to provide simplicity, but I see Swift is even slower than garbage collected languages.

So if your use case needs both performance and safety, Rust is your best bet.

It seems that from simplicity, performance, safety you can only pick two at once.

Microsoft Research is working on a language inspired by Rust. I'm curious if they can come up with something as safe but easier to use. I wouldn't bet on it. They aren't convinced of the outcome since they recommended to write or rewrite parts of their software in Rust instead of waiting for the new magical language.

A good thing from Microsoft evaluating Rust to use in their huge code base is they learned about a few weak points and are making recommendation to Rust team.

One side effect of Microsoft embracing Rust might be that other corporations like Google and Oracle might avoid it to distance themselves from Microsoft.

Google is using Rust on Fuchsia, but isn't keen in exposing it to userspace apps.

https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master...

Google already writes a bunch of Rust. Oracle did too, though the open source project seems abandoned and I’m not sure about the current state.

To better illustrate this, compare with Brainfuck. It is also a very small, simple language.

Its simplicity is at the same time its own worst enemy, in that it pushes down all the difficulties, complexities and verbosity for you to manage yourself. Perhaps an extreme comparison but just to show that simpler language doesn't always yield a simpler program.

C is easy, programming, hard.

C is easy, programming it correctly, hard.

It might depend on what you use C for.

Programming web apps and lob software in C might be tough. As would trying to program systems software in Python or Java.

https://stackoverflow.com/questions/21177436/is-there-a-publ... 6 years ago.

I was going to compare how many pages the rust standard has, and compare it to the C standard (plus 20% for the "correctly manage memory" that you pointed out as something extremely complicated). http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf

Anyway.. C is a rather simple language. No matter what the opinion of rust programmers is.

Please don't respond to this post. At least not with the bog standard "undefined" "unsafe/memory" and other shallow conceptions.

> plus 20% for the "correctly manage memory"

Sorry. "correctly manage memory" in C is not 20% more problematic, it's like dividing by 0, infinity% more problematic.

Nobody has gotten it right. Ever. Nobody.

The Mozilla team switched from C to C++ trying to get memory right. Failed. Then they tried GC. Failed. Then they tried to go back to manual. Sill failed.

So they wrote their own language to solve the problem--Rust.

Jury is still out, but the situation is a lot better than when Mozilla started.

> The Mozilla team switched from C to C++ trying to get memory right. Failed.

Still Mozilla software, including Firefox, run at more than 80% in C++ and are fully usable right now.

It is also the case of probably almost all the software you see on your own desktop right now... Most of them are C++.

Meaning, all considered, your notion of "failed" is pretty relative and opiniated.

Do you know how old and widely used C was when it got its spec ?

The work on ANSI C started in 1983, 11 years after C came out. And it took 6 years! to complete.

If Rust is as sucesful as C was during its 11 first years, Rust will most likely get a formal spec eventually. But don't hold your breath because it's going to take a loooong time to get there.

I teach Rust and C to college sophomores and juniors. By far the things they have the hardest time with in C are manual memory management, when to free variables, how to debug segfaults (usually called by incorrectly freeing memory), and how to correctly link code. We spend so much time on this I can't tell you.

With Rust none of these things are issues and we get to actually spend time solving problems in the language instead of just understanding the language. Yes, C is as simpler language, but it's got no safety rails, and when you're a beginner at systems programming it's nice to have a friendly compiler who can help you pinpoint errors rather than to be shown "SEGMENTATION FAULT" and feel like you're on your own.

Some things are a lot simpler in Rust.

For example, adding dependencies. And this one thing makes a lot of practical tasks simpler too, because there is a whole swathe of code you simply don't need to implement at all.

What's simpler: Implementing a HashMap in C, or `use std::collections::HashMap`? If you really need to understand what's going on under the hood then yes C might be simpler. But when was the last time you needed to inspect the details of your HashMap?

There are also things like C's declaration syntax, which is anything but simple. And header files (even for your own code).

On that “use HashMap” line of thinking... http://dtrace.org/blogs/bmc/2018/09/28/the-relative-performa...

What a weird article… The instruction count being about the same doesn’t make it the same program… Why isn’t he using -O3?

It's far easier to use Dictionary in C# than HashMap in Rust.

However we aren't comparing languages here but standard libraries.

If we introduce modules in C instead of header files and add some simple data structures and algorithms to stdlib, I can see C being simpler.

C++ has data structures in its standard library and will have modules starting with C++20.

Rust HashMap[0] is much simpler to use than C# Dictionary[1]:

Rust:

    let mut map = HashMap::new();
    map.insert("foo", "bar");
    println!("Value: {}", map.get("baz").unwrap_or("<none>"));

C#

    Dictionary<string, string> dict = new Dictionary<string, string>();
    dict.Add("foo", "bar");
    try {
        Console.WriteLine("Value: {0}", dict["baz"]);
    } catch (KeyNotFoundException) {
        Console.WriteLine("Value: <none>.");
    }

[0]: https://doc.rust-lang.org/rust-by-example/std/hash.html

[1]: https://docs.microsoft.com/en-us/dotnet/api/system.collectio...

I fail to see what Rust wins in the given example, when the C# code is written properly:

    var dict = new Dictionary<string, string> { ["foo"] = "bar" };
    Console.WriteLine($"Value: {dict.GetValueOrDefault("baz", " <none>.")}");

Better look for another example.

I'm with you on this one. The Rust and C# API's are more or less equivalent. That does still repudiate the grandparent's assertion that it's easier the use C#'s dictionary.

But arguably what makes rust hard to write is the borrow checker which eliminates a lot of painful runtime debugging.

I agree with this. I've found that students who struggle with the borrow checker also write code that tends to segfault in C. Rust is nice in that once you get it to compile it pretty much works. It's not going to segfault. I've also found that when students master the borrow checker in Rust, they write better C code.

If you don’t need to understand/inspect the details of a HashMap implementation then you are not doing ‘systems programming’. The attitude that ‘someone has done it for me’ and therefore I don’t care about it is not a characteristic of ‘systems programming’. It may be simpler to just use some standard implementation of a data structure, but if that is the case, then you can get by with most of the commonly accepted language paradigms. I’m not saying everyone need to implement a unique hashing algorithm tailored to use case, but that is what systems programming is.

System Programming is the custom tailoring of data conditioning to a particular set of circumstances and then taking responsibility for the benefits and consequences of that those choices that differentiates systems programming from the other broad categories of program construction.

Rust is a fine language if it fits your use case, and you feel as though the purported benefits of the ‘borrow checker’ assist you in writing quality code, but if you just want a programming language that provides a large library of pre-written solutions, then the difference between language is dependent only on use case and usage requirements. Saying Rust is simpler than C because you can use a pre-written HashMap implementation is ridiculous, because you can do the same thing in C (I mean use someone else’s HashMap). But if ‘systems programming’ is the area of interest, being able to inspect/implement the actual HashMap is a key concern, and just dismissing that aspect is not an acceptable proposition.

> If you don’t need to understand/inspect the details of a HashMap implementation then you are not doing ‘systems programming’. The attitude that ‘someone has done it for me’ and therefore I don’t care about it is not a characteristic of ‘systems programming’.

Don't gatekeep. Rolling your own containers has no bearing on whether or not the language is a systems programming language.

I'm using it to do real time audio and graphics, but I don't have the time to hand roll my own data structures because I have a demanding day job and other responsibilities. I still get to have the benefit of using a fast, modern, bare metal language.

> Saying Rust is simpler than C because you can use a pre-written HashMap implementation is ridiculous

No it's not. HashMap is literally there in std::collections to import and use. You don't need to find a library, know about the linker, etc.

Rust makes working in this domain so much easier than C and C++. You can go from zero to productive in a reasonable amount of time.

> Rust makes working in this domain so much easier than C and C++

C++ has a hash map in its standard Library since 10 years.

> You can go from zero to productive in a reasonable amount of time.

That's definitively a very WRONG assumption. Anyone starting to use Rust, even with 10 years of C++ experience, will spend from HOURS to DAYS fighting the borrow checker.

It is not "zero to productive", Rust is not easy to learn, nor productive for beginner.

Is it however worth the effort ? I believe it is. Especially if you are looking for a language providing you safety first.

> C++ has a hash map in its standard Library since 10 years.

OP was talking about C, not C++/STL.

> Anyone starting to use Rust, even with 10 years of C++ experience, will spend from HOURS to DAYS fighting the borrow checker.

You might have learned Rust pre-1.0 or non lexical lifetimes. They've made a tremendous amount of work to improve the language and make it beginner friendly.

A few weeks ago I watched one of my coworkers implement a simple toy state machine app after having just read a tutorial. The compiler literally hand holds you now.

The meme that Rust is hard needs to die.

> You might have learned Rust pre-1.0 or non lexical lifetimes. They've made a tremendous amount of work to improve the language and make it beginner friendly.

I still use Rust almost every week for personal projects, I enjoy it and I still would not qualify it as quick "zero to productive". It still fall behind C++ in term of productivity for me.

Many things that few lines of C++ allow you to do in few lines requires mental gymnastic to wrap around the borrow checker, strict typing and Rust error report system in 10-20 lines.

Comparatively speaking, I program in C++ since 15 years and in Rust since 3 years. Still, everything I do in rust takes between 1.5X to 3X more times to do than in C++, even if the tooling is better.

I know I am going to make enemies saying that with the number of Rust fanboys on YC, but... this is my experience.

And it is not a surprising experience.... Anyone that programmed in OCaml or strict typing language like ATS already experienced that... The strict typing gives you runtime safety and make your program "just" run (less bug-prone) compared to Weaker typed language....

But... it has a cost... like everything... And the cost is much more mental gymnastic... meaning time... meaning less productivity.

C itself isn’t complicated. But everything around it is harder than Rust imho.

Stuff like build systems, setting up dependencies, understanding memory allocation etc...

Rust has its own steep learning curve but C is only really simple in terms of a language, not the experience of using the language.

I'm using C++ daily at work and know Rust since it's alpha versions. C++ is miles harder to learn and write in than Rust, partially because of layers of legacy cruft in the standard, some bad decisions made that they can't undo now so they will stay forever (e.g., 50+ ways to initialise an instance, with constructors and all that, vs. Rust's lack of ctors). I still reach for reference all the time when writing in C++, but barely if at all when writing in Rust.

C++ might not be harder in theory but at least for me right now it is a lot harder to learn than rust. C++ just has so much stuff and different ways of doing things (of course, it's been in use for decades) that it I feel quite lost as a beginner on what to actually use.

Also in my experiences the rust compiler errors are extremely helpful, especially compared to the c++ template stuff.

> I don't want to come off as a Rust fanboy.

There's nothing wrong with that. People need to see that everyone around them is catching the Rust bug.

I want people to feel like they're missing out so that they too will take the plunge. The sooner everyone knows Rust, the sooner employers will start using it internally.

You don't need people who are learning their first "systems language" to evangelize. You actually need to convince C and C++ programmers, who are largely put off by the hype.

Rust seems to be popular only in the web sphere, where Javascript and Python programmers are tweeting that they now know a "systems language".

> Rust seems to be popular only in the web sphere, where Javascript and Python programmers are tweeting that they now know a "systems language".

I see that is the best thing Rust brings to the table, as the scope of learning and using Rust is pretty much “scoped “. Once you are comfortable with the compiler, you can use Rust reliably and deloy code to production. Whereas C/C++ is very “open” to learn, you can learn the syntax and basic in a couple of weeks, but to use it correctly and reliably (to a certain degree) WITHOUT SUPERVISION from another advanced programmers takes years of experience under your belt.

Yeah! I'm not about to go acting like I'm a systems programmer. I'm not writing drivers. But there's a lot of CS principles you just don't get exposed to when writing web stuff and that's what I'm after. Just knowing those things better will make be a better programmer, even if I never use rust professionally.

>Rust seems to be popular only in the web sphere, where Javascript and Python programmers are tweeting that they now know a "systems language".

This is great because now we are starting to get faster, more performant libraries and code. People switching from Node to Rust see huge speedups. Perhaps we'll also switch from JS to rust with WASM. Rust is nice because it's high level enough to write code with algebraic data types, like in TypeScript, so that maintenance is easier. Personally I'd love to see as many people as possible move from JS and Python to Rust.

Is there a way to use it with Clion? I didn't find anything right away. Although the Clion/Rust story is already pretty good.

You can use the intellij rust plugin with clion. Not the same thing but similar.

Does clion/intellij use its own analyzer or embed an open source one?

It has its own.

I believe that the CLion/IntelliJ plugin and rust-analyser were authored by the same people, and that one of the primary maintainers now works with Ferrous Systems.

the rust plugin for intellij is pretty damn good. sometimes it doesn't catch downstream errors when you mess something up but it's on point probably 80% of the time.

After reading your comment I tried Rust Analyzer and wow, it makes a huge difference. I was previously using rls and it was misssing a few key features (I didn't even realize it).

Thank you for the suggestion :-)

rust-analyzer doesn't work well for me, I can't click through functions to get to definitions. There's a bunch of things that just stop working. So I'm still on RLS and it's not great.

That definitely works for me - it's an option under the right-click menu.

> The problem I had was basically the IDE integration in VSCode.

I use vi. Works every time.

I really hope vs code wasn't electron. So that I could use it.

There's a time and place for everything, but not now.

You get the same experience with rust-analyzer in emacs. Like the addition of code actions was a game changer for me.