Top products from r/rust
We found 37 product mentions on r/rust. We ranked the 26 resulting products by number of redditors who mentioned them. Here are the top 20.
1. Programming Rust: Fast, Safe Systems Development
Sentiment score: 3
Number of reviews: 6
2. Programming Rust: Fast, Safe Systems Development
Sentiment score: 3
Number of reviews: 3
4. Purely Functional Data Structures
Sentiment score: 1
Number of reviews: 3
Used Book in Good Condition
5. Flexible Pattern Matching in Strings: Practical On-Line Search Algorithms for Texts and Biological Sequences
Sentiment score: 1
Number of reviews: 1
6. Seagate BarraCuda 8TB Internal Hard Drive HDD – 3.5 Inch Sata 6 Gb/s 5400 RPM 256MB Cache for Computer Desktop PC – Frustration Free Packaging (ST8000DM004)
Sentiment score: 1
Number of reviews: 1
Store more, compute faster, and do it confidently with the proven reliability of BarraCuda internal hard drivesBuild a power house gaming computer or desktop setup with a variety of capacities and form factorsThe go to SATA hard drive solution for nearly every PC application from music to video to p...
7. Rust Programming By Example: Enter the world of Rust by building engaging, concurrent, reactive, and robust applications
Sentiment score: 0
Number of reviews: 1
9. Introduction to 64 Bit Intel Assembly Language Programming for Linux
Sentiment score: 1
Number of reviews: 1
10. Programming the 68000
Sentiment score: -1
Number of reviews: 1
Used Book in Good Condition
11. Making Software: What Really Works, and Why We Believe It
Sentiment score: 0
Number of reviews: 1
O Reilly Media
12. Mastering Regular Expressions
Sentiment score: 0
Number of reviews: 1
O Reilly Media
13. Unix Network Programming, Volume 1: The Sockets Networking API (3rd Edition)
Sentiment score: 0
Number of reviews: 1
14. Concurrency in Ada
Sentiment score: 1
Number of reviews: 1
Used Book in Good Condition
15. Component Software: Beyond Object-Oriented Programming, 2/E (Addison-wesley Component Software)
Sentiment score: 0
Number of reviews: 1
16. Don't Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition
Sentiment score: 1
Number of reviews: 1
test
17. Accelerated C++: Practical Programming by Example
Sentiment score: 1
Number of reviews: 1
Addison-Wesley Professional
18. OpenGL Programming for Windows 95 and Windows NT
Sentiment score: 1
Number of reviews: 1
Rust is currently premature but that is only temporary. You don't have to restrict yourself to only a single language. Try it and see how it goes. Rustbyexample and the guide set the barrier pretty low as far as trying things out (although, windows support may currently only be mediocre). Rustbyexample in particular because everything can be run in place (without downloading anything). Concepts in one language extend to others so learning one helps with others.
---
Some of the following comments about Rust may also extend to other language like python. For example, python has a well organized and seemingly comprehensive documentation set on their main site which is a huge help. Other (newer) languages may also.
If you intend to learn it using the internet only (without printed books) then C++ may not be a good choice (in my experience). This C++ tutorial is pretty good but it is extremely brief compared to a book like Accelerated C++ which is compact, detailed, and covers much more material than the tutorial will (it may be difficult for a beginner though).
Rust doesn't currently have the luxury of referring to good books for instruction. So best practices and coding conventions are being baked directly into the compiler/guidelines pages (currently WIP)/the guide. This is really convenient compared to C++ where resources are much more scattered (aside from books).
Inevitably, if you try writing something though in either language, you will get confused/perplexed by something regardless of the quality of documentation. In those cases, having IRC for help is incredibly helpful. They can save you hours upon hours of mystification. The Rust IRC is extremely extremely helpful in that regard.
Rust has cargo which makes testing new things incredibly easy. My experience with C++ is you find a new repository you want to test, you download it and spend the next 2 hours trying to get dependencies in order so you can compile it. With cargo, you often run this and you're done:
git clone site:repository
cargo build
The C++ compiler is notoriously unhelpful also which extremely confusing especially to a beginner. It is commonly the case that it finds some issue on line 12. When you eventually find the error, it's on line 20 (the compiler points you to the wrong location). What kind of issue could it be...maybe you forgot a semicolon. In general, the rust compiler is much more helpful with regard to error messages. If there is a confusing error message, the compiler team would like to make it better. If you're still confused, there is always IRC.
C++ has a lot of IDE support which is very helpful for advanced projects. Rust currently doesn't (Python doesn't seem to either). This will probably improve in the future. Also, IDE support often costs money depending on the language.
> To be honest I don't entirely understand the term "functional data structure" I'm sort of new to functional programming myself.
I'm sure you're familiar with the idea of an immutable
int
ordouble
or evenstring
. Purely functional data structures just extend this idea to collections like lists, arrays, sets, maps, stacks, queues, dictionaries and so on. Whereas operations on mutable collections take the operation and collection and return nothing, operations on purely functional data structures return a new data structure.Here's an example signature for a mutable set:
val empty : unit -> Set<'a>
val contains : 'a -> Set<'a> -> bool
val add : 'a -> Set<'a> -> unit
val remove : 'a -> Set<'a> -> unit
and here is the equivalent for a purely functional set:
val empty : Set<'a>
val contains : 'a -> Set<'a> -> bool
val add : 'a -> Set<'a> -> Set<'a>
val remove : 'a -> Set<'a> -> Set<'a>
Note that
empty
is now just a value rather than a function (because you cannot mutate it!) andadd
andremove
return new sets.The advantages of purely functional data structures are:
The disadvantages are:
The obvious solution is to copy the entire input data structure but it turns out it can be done much more efficiently than that. In particular, if all collections are balanced trees then almost every imaginable operation can be done in O(log n) time complexity.
Chris Okasaki's PhD thesis that was turned into a book is the standard monograph on the subject.
In practice, purely functional APIs are perhaps the most useful application of purely functional data structures. For example, you can give whole collections to "alien" code safe in the knowledge that your own copy cannot be mutated.
If you want to get started with purely functional data structures just dick around with lists in OCaml or F#. Create a little list:
> let xs = [2;3];;
val int list = [2; 3]
create a couple of new lists by prepending different values onto the original list:
> list ys = 5::xs;;
val int list = [5; 2; 3]
> list zs = 6::xs;;
val int list = [6; 2; 3]
> xs;;
val int list = [2; 3]
Note how prepending
5
ontoxs
didn't alterxs
so it could still be reused even afterys
had operated on it.You might also want to check out my Benefits of OCaml web page. I'd love to see the symbolic manipulation and interpreter examples translated into Rust!
> Personally I used Atom for a while, until I learned how to use Vim, now I use that. IDE information for Rust can be found at https://areweideyet.com/
Excellent. I'll check it out, thanks.
Rust is a pretty high level language if you're trying to learn assembly and/or shellcode. You might be better off writing C and compiling with no optimization and looking at what's generated with the -S flag, or just no optimization and using objdump or radare2 to disassemble it.
If you want to learn low level linux stuff I highly recommend this awesome book available as a free PDF, the Linux Programming Interface. It goes into very deep detail and has example C code in it. Over a thousand awesome pages. I read through most of it except for the pseudo-terminal stuff because that is confusing as all hell. Another great book is "Introduction to 64 Bit Intel Assembly Language Programming for Linux" (Amazon.com), and you also might want to pick up a newer Instruction Set Reference for intel processors.
You also might take a look at MSFvenom and look at the encoder modules.
I worked on a Game Boy emulator and read the Programming Rust: Fast, Safe Systems Development book when i was in a similar situation.
I found the emulator was a big enough project to learn new stuff and get practice with the borrow checker, but it was probably a little too large. If emulators are interesting to you maybe a chip-8 emulator would be a better size project.
The book is great for learning a little bit more about the details of rust and how things are implemented. It assumes you're somewhat knowledgeable in programming which is part of why i like it so much.
\> "The thing which might be getting in the way is your attitude."
&#x200B;
I have a big ege and also ADHD. See: https://www.youtube.com/playlist?list=PLXcr3tdUCbQaZGyjf0Bp9E6gj2pWxLrVw
&#x200B;
If you hire me, you also get my ego and my ADHD (mental health related) because those things are part of me.
&#x200B;
\> "but if it does, when you leave out an impression of very annoying type of beginner/junior who probably gonna be resistant to learning anything."
&#x200B;
I am annoying (I got it from my mother). I like attention. That being said, I can learn a lot really fast.
&#x200B;
See: https://twitter.com/JohnReedForPres/status/1107447298043375616
&#x200B;
Because of my attention span, I can hyper-focus on things that I am interested in and cram really fast. I don't really consider myself junior at say Bank of America because I wrote and provided the setup instructions, tutorials, educational resources, and even the plan for a new microservice, and people maybe 15 years my senior followed what I layed out. Because of my obsessive cramming of technical information, I can become a subject matter expert. I can also write a lot of code very very fast. For example, in college, I wrote maybe 15,000 lines of Java code in a 7 day (168 hour period) in coordination with a friend who added (I dunno 7k lines of code). I did the backend and he did the frontend.
&#x200B;
\> "who probably gonna be resistant to learning anything."
&#x200B;
Because of my ADHD, I don't listen to verbal commands well, but I do accept reasoning in written and textual formats. For example, I communicate better over text than spoken word, and I can text super fast on my phone. My texting is as fast as my computer typing, and I also take email, Tweets, and other form of text-based communication.
&#x200B;
\> "I think this highlights it in particular. Provided it showed up in somewhat generally condescending context. It appears that instead of thinking that there is a reason for it, you write it off as something stupid."
&#x200B;
I don't mean that the fact that people want braindead simple stuff is stupid. I think that is great. I think that most people are unintelligent relative to me, and also technologically inept, and so the design has to be made with that in account. "Don't make me think!".
Please have a look at all these:
https://www.adaic.org/resources/add_content/standards/05aarm/html/AA-STDS.html
https://www.amazon.ca/Concurrency-Ada-Alan-Burns/dp/052162911X#reader_052162911X
Now count the number of pages involved to read all these.
None of the rust books I have been exposed to reach the level of complexity that I have read within ada.
When I speak about rust's ability to express a problem, it does not mean ada cannot express it, but I simply believe rust can express it in a manner that is more maintainable(easier to read) and gets the efficiency and safety for free if you can compile it successfully without having to read all those ada books about ada rationale, ada library api's and ada concurrency.
Blandy \& Orendorff's Programming Rust is an amazingly good book, well worth the money. The official Rust Book is solid and free online. Steve Donovan's Gentle Introduction is a great online tutorial also.
All of these presume you know a little bit about programming and how a computer is organized, though. If you are a genuine novice programmer, there's not much out there that I'm aware of on Rust as a first serious programming language. Python is generally the first language of choice for most people these days.
Aye. And personally, I'm not a huge fan of using edit distance for fuzzy searches in most cases. I've found n-gram (with n=3 or n=4) to be much more effective. And you can use that in conjunction with bitap, for example, by using an n-gram index to narrow down your search space. I use an n-gram index in imdb-rename.
If you like algorithms like bitap, you'll definitely like Flexible Pattern Matching in Strings, which covers generalizations of bitaps for regexes themselves, for both Thompson and Glushkov automata.
Here you go:
I don't know if that's the cheapest place to get it - I did some quick googling and couldn't find anywhere else to buy it from.
I know I sound like a shill, but that book is probably my favorite resource (besides google).
I second OSTEP; hands down the best introductory OS book.
Also, to learn systems programming from the ground up, [Computer Systems: A Programmer's Perspective] (https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X) is a monumental work.
This is excellent:
https://www.amazon.com/Programming-Rust-Fast-Systems-Development/dp/1491927283
Googling if this was possible I came about this book which seems like the source of the weird lego-planet wall-texture thing lol: https://www.amazon.com/OpenGL-Programming-Windows-95-NT/dp/0201407094
Link to Amazon for those interested: https://www.amazon.com/Programming-Rust-Fast-Systems-Development/dp/1491927283/
I often do. Usually when I build a new workstation I buy a couple decent sized drives. Cold storage is pretty cheap these days. https://smile.amazon.com/dp/B07H289S7C 20$ per Terabyte
> there are real studies
have you read http://www.amazon.com/Making-Software-Really-Works-Believe/dp/0596808321 ? It's really interesting.
It’s free online but
https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284
The book is now available for pre-order on Amazon UK: https://www.amazon.co.uk/dp/1593278284/
The OReilly book will also be out soon. It just went pre-order on Amazon.
https://www.amazon.com/Programming-Rust-Fast-Systems-Development/dp/1491927283/ref=sr_1_1?ie=UTF8&amp;qid=1511901824&amp;sr=8-1&amp;keywords=Programming+Rust
Well,if you want to buy something related to Rust,you can buy these 2 books:
- http://shop.oreilly.com/product/0636920040385.do
- https://www.amazon.com/Rust-Programming-Language-Steve-Klabnik/dp/1593278284
The ISBNs are the same, so it is likely that they are the same book and the data on the UK site is just out of date.
Tokio has a tutorial which introduces tokio and futures.
There is a guide started by Aaron Turon, but it hadn't been updated for a while.
For more deep introduction to network programming I'd recomend Steven's book on Unix network programming, but it is not Rust, but C.
I learned C at uni (in 1996) and the book we used was "A Book on C" by Kelley and Pohl (http://www.amazon.com/Book-Programming-4th-Edition/dp/0201183994)
UML does also apply to Rust, you can restrain yourself to the subset known as Component Based Software:
https://en.wikipedia.org/wiki/Component-based_software_engineering
Here is one of the reference books on the subject:
https://www.amazon.com/Component-Software-Object-Oriented-Programming-Addison-wesley/dp/032175302X
Basically traits can be seen as components, and you design the interactions among them.
Why not link directly to the content?
link
immutable data can cause problems with data structures and the like, here's a book on the topic.
http://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki/dp/0521663504?ie=UTF8&amp;*Version*=1&amp;*entries*=0
> FWIW, a persistent data structure is somewhat orthogonal to laziness.
But you do need lazy evaluation (in-place update of thunks, whether that's provided by the language or a library) to get amortized time guarantees on persistent data structures. How much this matters in practice, I do not know.
This kind of stings if you just bought this on Amazon.
OT: has anyone bought https://www.amazon.com/Rust-Programming-Example-concurrent-applications/dp/1788390636/
The TOC looks great but I have had bad experiences with Packt
Yea, we need Rust on Amiga, Atari, etc. too. But I grew up writing games for the TI-68k calculators (because my parents didn't allow me to have a gaming console) so that's where my heart is..
Unfortunately the TI calc scene is even more dead than the demoscene these days :/
But I still have my two TI-Voyage 200 calcs, and I still use them often instead of Wolframalpha..
I also still have a very old book called "Programming the 68000" from 1985 that's all about m68k asm coding, and its cover looks very aesthetic, too.