Best products from r/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.

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

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.

You may want to go through Jonhoo's youtube channel or dig around in SmolTCP. Other recommended resources out there right now are this tutorial and the packt book.

With that said, there are a lot of changes happening to Rust’s networking story, so unless you are up for the challenge, may be better to use Go, or more traditional options like C++/C, until the ecosystem is a bit more mature.

Also might be worth checking out https://github.com/rustasync. It's a good showcase of why there is a lot of excitement around networking in Rust, though most of the examples there do not work off of stable.

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

​

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

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:

• Amazon "Programming Rust: Fast, Safe Systems Development" (Kindle)
  
  
• O'Riley shop page
  
  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/

Yeah, you're right about that! I just added the Rode shock mount to my wishlist :)

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.

The only "real" payed book that is currently out is "Rust Essentials". It seems you are better off using the official documentation than this one. Amazon reviews

Modern operating systems by Andrew Tanenbaum

I think that system programmers should know how OSs work. Concepts like virtual memory, the call stack and paging may be the answer to your question about when to consider something to be big

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&qid=1511901824&sr=8-1&keywords=Programming+Rust

Somewhat off the topic of Rust code, but your woes of waking up piqued my interest. I used to have the exact same problem. Tried lots of things to no avail, but I finally got a sunrise simulation alarm clock and it has worked out really well for me. It turns out that most of the time my room is really dark (blinds closed, etc.), so there's very little natural light in the morning. The sunrise simulation slowly raises the brightness of the room for about half an hour until the alarm goes off, which triggers your body's normal reaction to slowly bring you out of deep sleep.

It really has worked wonders for me. I may wake up feeling tired or well rested depending on how long I slept for, but I always wake up and no longer play those silly alarm clock games just to get up on time. I think I'm also making more efficient use of my sleep time as well, since I don't have to set multiple alarms starting 1-2 hours in advance of the time I really need to be up.

This is the clock that I got, though that's quite pricey. I got it on Amazon for $120, so maybe you can find it cheaper somewhere else.

TL;DR: Offtopic sleep talk. Now back to your regularly scheduled Rust banter...

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

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.

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.

• https://www.amazon.co.uk/dp/1491927283/
  
• https://www.amazon.com/dp/1491927283/

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&*Version*=1&*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.