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.

Next page

Top comments that mention products on r/rust:

u/mdinger_ · 1 pointr/rust

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.

u/jdh30 · 2 pointsr/rust

> 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 or double or even string. 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!) and add and remove return new sets.

The advantages of purely functional data structures are:

  • Makes it much easier to reason about programs because even collections never get mutated.
  • Backtracking in logic programming is a no-brainer: just reuse the old version of a collection.
  • Free infinite undo buffers because all old versions can be recorded.
  • Better incrementality so shorter pauses in low latency programs.
  • No more "this collection was mutated while you were iterating it" problems.

    The disadvantages are:

  • Can result in more verbose code, e.g. graph algorithms often require a lot more code.
  • Can be much slower than mutable collections. For example, there is no fast purely functional dictionary data structure: they are all ~10x slower than a decent hash table.

    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 onto xs didn't alter xs so it could still be reused even after ys 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.
u/d4rch0n · 7 pointsr/rust

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.

u/squidboylan · 9 pointsr/rust

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.

u/JohnReedForPresident · 1 pointr/rust

\> "The thing which might be getting in the way is your attitude."

​

I have a big ege and also ADHD. See: https://www.youtube.com/playlist?list=PLXcr3tdUCbQaZGyjf0Bp9E6gj2pWxLrVw

​

If you hire me, you also get my ego and my ADHD (mental health related) because those things are part of me.

​

\> "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."

​

I am annoying (I got it from my mother). I like attention. That being said, I can learn a lot really fast.

​

See: https://twitter.com/JohnReedForPres/status/1107447298043375616

​

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.

​

\> "who probably gonna be resistant to learning anything."

​

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.

​

\> "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."

​

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!".

u/omac777 · 1 pointr/rust

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.

u/po8 · 8 pointsr/rust

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.

u/burntsushi · 8 pointsr/rust

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.

u/wongsta · 6 pointsr/rust

Here you go:

u/Zardov · 1 pointr/rust

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.

u/clrnd · 9 pointsr/rust

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

u/huhlig · 3 pointsr/rust

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

u/rammstein_koala · 1 pointr/rust

The book is now available for pre-order on Amazon UK: https://www.amazon.co.uk/dp/1593278284/

u/1331 · 6 pointsr/rust

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.

u/serejkus · 3 pointsr/rust

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.

u/itkovian · 1 pointr/rust

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)

u/pjmlp · 8 pointsr/rust

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.

u/GeekBoy373 · 3 pointsr/rust

Why not link directly to the content?

link

u/mozilla_kmc · 1 pointr/rust

> 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.

u/pkx3 · 9 pointsr/rust

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

u/boscop · 1 pointr/rust

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.