Lurklurk

been awhile sincei looked but i thought Drysdale's Effective Rust was a truly excellent book and aimed at simlar audience https://www.lurklurk.org/effective-rust/

The "Effective Rust" book was recently published and can be read online, for free [1]. I'd go as far and say that all of it is, by definition, idiomatic. I guess I'm saying, you could reasonably change the book's title to "Idiomatic Rust". I'd read that first and then look into what bits it doesn't cover. That could be worth a blog like the one this is about. [1] https://www.lurklurk.org/effective-rust/

> For Compatibility with no_std tgts, e.g. embedded, Use the no_std feature. Note, this is not the recommended way to use Rust feature flags. They are additive and so the correct way to make a `no_std` compatible crate is to have a `std` feature flag that conditionally enables use of the `std` library. Referring to Effective Rust: > Note that there's a trap for the unwary here: don't have a no_std feature that disables functionality requiring std (or a no_alloc feature similarly). As explained in Item 26, features need to be additive, and there's no way to combine two users of the crate where one configures no_std and one doesn't—the former will trigger the removal of code that the latter relies on. - https://www.lurklurk.org/effective-rust/no-std.html

Pros: popular and commonly used; good for data science Cons: roughly the same paradigm and Javascript. weak/dynamic/duck typed, interpreted, garbage-collected. I'd recommend learning a language that departs from one or more of those. Maybe learn a statically-typed language, or a functional language. If you're up for a bit of a challenge, learn Rust. It's strongly typed, compiled, and definitely NOT garbage collected. It's possible to get a running program very quickly, but the learning curve steepens after that. If you do want to try Rust, here's some starting points - https://chrismorgan.info/blog/rust-fizzbuzz/ - https://stevedonovan.github.io/rust-gentle-intro/readme.html - https://www.lurklurk.org/effective-rust/intro.html - https://fasterthanli.me/articles/a-half-hour-to-learn-rust

https://www.lulu.com/ I used lulu.com to print a copy of OnLisp [1] What I got was one of the best bound paperback books I've ever held. <rant> I wish all publishers would just sell eBooks (and publish settings like "optimal paper size") so that I could print my own copy using a service like lulu. One of my biggest gripes with hardcopy books nowadays is that the paper stock they use is so thin that the ink on the other side of the page shows through. Lulu let's you choose the paper stock. I really can't say enough about how happy I was with the quality of the printed book lulu sent me. </rant> [1] https://www.lurklurk.org/onlisp/onlisp.html

Instructions for printing it with lulu: http://www.lurklurk.org/onlisp/onlisp.html . I did this about a month ago and the copy I received was great.

The art of the interpreter: http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AIM-453.pdf On lisp: https://www.lurklurk.org/onlisp/onlisp.pdf Mainly the key is to start tinkering, rather than jump from book to book. Just start with a very informal v1 and start hacking stuff together. When you run into a design dead-end, you'll know it because it will become increasingly hard to make forward progress. And that's the tricky situation. When you run into a design dead end, what do you do? Books! :) And that's where SICP might end up useful. Or think about the problem really hard, and write down the answer. I've occasionally pulled that off. Oh, I thought of one other suggestion: linkers and loaders. It's another classic. And unlike all the other references, there's no Lisp. Two more: Linkers, Ian Taylor: https://www.docdroid.net/2L1IZ5y/linkers.pdf Assemblers: https://www.docdroid.net/2tgkwNI/assemadvertisasl.pdf

> I agree Rust is easy to learn. I've done it 4 or 5 times now. https://www.lurklurk.org/effective-rust/ could be for you; while it starts from the very basics—for a person that knows how to program—it does seem to cover a lot and in a structured manner. I expect one to learn something new at least something by page 70 :).

Sorry, none of this is relevant to "idiomatic rust". It's just a list of a few random ... things. That, combined with the site name "a-i-nstein", makes me pretty confident that this is LLM slop. For folks looking for actual guidance on "idiomatic rust", I highly encourage you to check out "Effective Rust" [1]. [1] https://www.lurklurk.org/effective-rust

Reminds me of `diags` from [0]. Side note: can we make 'file not found' errors that fail to mention what wasn't found illegal? What's the point of 'file not found', then keeping silent about the exact file? Seen it in various ecosystems now. [0]: https://www.lurklurk.org/effective-rust/macros.html#when-to-use-macros

I appreciate the author's efforts and amount of time that went into this. But, IMHO, there are some things that are just plain bad advice: e.g. https://www.lurklurk.org/effective-rust/panic.html "Another sensible use of panic!, even in library code, is in situations where it's very rare to encounter errors, and you don't want users to have to litter their code with .unwrap() calls." The litmus test for panic! vs. Result<T,E> is not rarity of occurrence, it's whether the condition represents a programming bug or a recoverable error. A good treatise on this topic here: https://joeduffyblog.com/2016/02/07/the-error-model/#bugs-arent-recove…

http://www.paulgraham.com/onlisp.html https://www.lurklurk.org/onlisp/onlisp.html

I have bookmarked this version with restored images: https://www.lurklurk.org/onlisp/onlisp.html

It looks like someone else found and re-added the diagrams: http://www.lurklurk.org/onlisp/onlisp.html

Typically anything that has the Wolfram name attached to it has the most gifted that money can hire doing the actual production. https://www.lurklurk.org/wolfram/review.html "Wolfram is careful never to actually claim credit for something he hasn't produced; however, he's good at wording the main text so that it implies he has discovered things. " I would not be surprised if this writing was much of the same.

It's also free here[0], though maybe in less convenient a form (PDF or postscript). :) On the other hand, if you'd prefer a physical copy, I used Lulu.com to print a book for just $22.42 including shipping. I used the PDF and instructions here[1], since it has missing diagrams and has the cover available. It turned out really well. [0] http://www.paulgraham.com/onlisptext.html [1] http://www.lurklurk.org/onlisp/onlisp.html

Happy birthday ! Discussion 2 weeks ago: https://news.ycombinator.com/item?id=6273692 In the discussion was mentioned this link (thanks @nonrecursive!) with instructions to print your own copy on lulu : http://www.lurklurk.org/onlisp/onlisp.html

A scripting language rosetta stone. Here's one http://www.lurklurk.org/rosetta.html

See also: https://www.lurklurk.org/effective-rust/

https://www.lurklurk.org/effective-rust/errors.html#minimal-errors has what seems (to my naive understanding) to be mis-statement. Given a trait: pub fn find_user(username: &str) -> Result<UserId, MyError> { let f = std::fs::File::open("/etc/passwd") .map_err(|e| format!("Failed to open password file: {:?}", e))?; // ... } and an error type: #[derive(Debug)] pub struct MyError(String); impl std::fmt::Display for MyError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, " {}", self.0) } } impl std::error::Error for MyError {} And an implementation of `From<String>` for `MyError`: impl std::convert::From<String> for MyError { fn from(msg: String) -> Self { Self(msg) } } The book asserts: > When it encounters the question mark operator (?), the compiler will automatically apply any relevant From trait implementations that are needed to reach the destination error return type. I thought that `?` only unwrapped `Option` and `Result` and was not overloadable. Is [the Rust doc on `?`][1] leaving something important out, or is this a mis-statement? [1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the…

Lots of Lisp interest today! Here are a few resources. On Lisp: https://www.lurklurk.org/onlisp/onlisp.pdf Lumen - a Lisp for JavaScript and Lua: https://github.com/sctb/lumen The Art of the Interpeter: https://dspace.mit.edu/bitstream/handle/1721.1/6094/AIM-453.pdf?sequen… (^ this last one is very practical. If you reach the point of wanting to implement a practical interpreter, this paper will force you to consider many unexpected cases.) Simulating circuits with Lisp: https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-… My favorite part of SICP: https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-… War stories: http://paulgraham.com/avg.html Lisp in Jak 'n Dexter / Crash Bandicoot: https://all-things-andy-gavin.com/2011/03/12/making-crash-bandicoot-go… Fun fact: Lisp is still used today in gamedev! Last of Us uses it heavily: https://www.youtube.com/watch?v=Ox2H3kUQByo&t=2415s