Hey everyone,
first of, I am really glad about Exercism, the work you put into this, and the #12in23 challenge. I am a computer science graduate, who did some programming at University and then I became a Java web developer, which I am doing for the last 5 years now, so I am not entirely new to programming, yet I never did much more than Java and I thought this challenge would be a good idea to dabble with some other languages. I did some Elixir and the track felt really good and I got along quite well.
Now for Rust this is an entirely different thing. I feel quite bad that my first post on this forum is criticism, but I hope it’s constructive. Or maybe it really is just me, maybe I am not getting how this is supposed to work. I’ve finished 7 exercises, following along with the syllabus. The Hello, World! and Lasagne were super easy, all information was in the description themself, no need to look things up; then came the Assembly Line exercise, and this one already had important concepts missing in the syllabus and the help text (match, _, panic!), but I was able to figure this out, and with the help of a mentor also managed to get a solution that looked quite nice. For Semi Structured Logs however, I was investing hours into understanding what I was doing wrong; the concept is Enums Basic, but the problems lie in the different (and at least to me untypical) handling of Strings in Rust. Information that I would have needed were things like owned vs. shared, String vs str vs Literal strings, Format strings. What’s a trait, what’s a Display, etc. For all these things there isn’t even a point on the Syllabus - but there are also no hints that could point you in the right direction. In the end, I spend reading the book, reading stack overflow, and googeling a lot, and in the end, you always find a solution that works, but I’d rather understand what to do, before I see a solution, and be able to find the answer myself. At least, that is what I believe is also the goal of Exercism? But to be able to do this, there needs to be at least a list of keywords to google?
I am at the same problem once more, now with the Low-Power Embedded Game. While there is a lot of information, the crucial part is missing: How do I get rid of cannot mod '&T' by '{integer}': &T, i.e. how do I cast this type into an int? Googling this will actually show me the solution to exactly this exercism task, as apparently others also struggled here and did not find a solution themselves; the solutions on the internet use concepts that I don’t quite get, and because they seem overly complicated (add this to the function signature where T: Eq + Copy + std::ops::Rem<Output=T> + TryFrom<i32> and then do something weird like T::try_from(0).ok().unwrap(); with the numbers 0 and 2 and also dereferencing the closure variable), so I also peeked into the community solutions after over an hour of frustration. And there, people are not using filter or map but simply use step_by(2).
So, my feedback at this point is the following: I feel that the information in the syllabus plus in the hints and the readme - including links - does not really help; there is somewhat of a mismatch between the information and the exercise itself. While the information is pretty basic, the problems that someone entirely new to the language faces, are rather hard. In fact, they are so complex that someone like me, who actually already has a lot of experience in programming is getting frustrated as well. I feel like I am missing out on essential concepts that I even don’t know how to name (like the where line). After getting stuck a lot, I actually started reading the Book - but even after having read a third of that, I am still struggling with Exercism.
In the Elixir track, this felt more in tune, I could easily follow along, I didn’t need to google, because I got the information I needed from the files and the linked documents. I read through the info, looked at the tests and knew what to do, and was able to find a solution. With rust, I feel like I know what to do, and then get stuck with high-level concepts that are not explained or hinted at and that take a huge amount of research with the risk of finding the solution to the problem (which is neither the point of Exercism nor is it helpful). In the end, I found myself looking forward to April, and hoping this will get better again, then. But that’s actually a quite sad thought, and totally different to my experience with Elixir, where I was actually sad that I had to stop, and wanted to go on with.
But maybe I am misunderstanding how to use this track? Am I the only one with these kinds of problems? How do others cope with this? Is there something I am doing wrong? Am I supposed to read the entire material presented at the information tab before even starting the exercises? (But wouldn’t a lot of them then be rather dull?)
It’s something we’ve been discussing for a little while. I want us to make a great Rust track, but it’s proven to be a hard language to do this for (not for lack of many people trying). So we should back up and try again but not leave something half-finished around to confuse people in the meantime! :)
), so now I worked through an entire book in depth, doing all the examples, etc. There are so many concepts that are simply different to any other language (slices, borrowing, ownership, lifeline variables, traits (and trait conditions)); when finished, I picked up Exercism again, and I manage to work through the exercises without feeling like having two left hands on the keyboard… but it’s still complicated with all these new concepts; I now get, why it’s complaining at certain points and what to do when Rust does - but I feel that it will take a much longer time until I manage to write something that’s error free on the first try.