New week, new Rust! What are you folks up to?
Over the holidays, I finally got my lock-free bitmap allocator past the "looks finished to me" line. Now I'm building a test suite to see if it's actually finished, and after that it will be time to benchmark it to revisit all those clever "higher-order" optimization ideas which I wasn't sure about and left out initially.
Then it'll probably be time to publish v0.1, and after that I can think back about all those user-level conveniences (realloc, Box-style abstraction, overalignment, GlobalAlloc impl...) which are not really part of the core functionality of the crate but might make it nicer to use. Hopefully I'll also get some interesting feedback.
And, once all that is done, I'll be done shaving that particular yak, so I'll put a v1 on it and will be able to go up one level of the call stack to resume shaving the previous yak, namely RT-safe variable-sized messaging.
Had my first play with
async/await, and made an app that:
- Reads a csv
- Retrieves additional info online for each entry
- Writes to another csv
- Shows progress
Part that am happy with is the
reqwest::Client manages cookies for you, so you can have a future that goes:
// returns immediately if cookie is still valid self.ensure_authenticated().await?; // send actual request
I've been working on a new tutorial for Tetra (working towards building a simple Pong clone) - the old one didn't really explain things very well, and 0.3 seemed like a good time to go back and rewrite it
I am working on a parser for common integer notations:
I'm working on extending my unsafe-first tutorial series to more areas, based on feedback I've gotten from the community. In particular, I'm adding a section on
packed_simd showing how you'd do SIMD optimization in native Rust. Then I figured I'd tackle a different program. (More feedback / suggestions wanted!)
I'm building a language (name is stupid, I know) that is somewhat like Scheme, but with some thoughts on how one could use less parentheses in some forms like
cond etc, as well as making stack-less language based on graph reduction. This is very much WIP and I don't think it will be ever ready for public use, because I have no clue how to make a language (and it is pure language, so it is useless anyway).
Currently I have working REPL, with
quote language primitives:
> (cons 1 2) '(1 . 2) > (car (cons 1 2)) 1 > (cdr (cons 'a (cons 'b '()))) '(b)
Name lookup and procedures are on the way (if I will not rewrrite everything from scratch as it happened before several times).
I'm fairly new to rust, so code is not very idiomatic. I'm planning to improve it over time, as I go through TRPL, and maybe it will be less cringy.
I'm building a lock-free software transactional memory system with an emphasis on composability and ease of use. The idea is that a user, relatively naive to best practices in concurrent data access, can just open a transaction, say "I need to read this item, write this item, etc", and have the STM system handle the details of commit and rollback for them. The idea is not to necessarily be the fastest option for concurrency, but to be "fast enough" that most people won't need to bother with the challenge of figuring out which locks should protect what and what order they should be acquired in, or building a bespoke lock-free solution.
Right now, I'm struggling with the problem of providing guarantees of "this item will not be freed before this other item" without lifetimes, as lifetimes are fairly tied to the call & scope stack. I've figured out a system I think will work though, so we'll see how it plays out.
Learning rust by working on a raytracer and recently added image texture mapping onto spheres. Rectangles and lighting are next.
To compare my own Rust based renderer against a commercial renderer, Arnold, which we use @ work, I started implementing a translator from .blend (Blender) to .ass (Arnold) files, which I shamelessly call btoa (Blender to Arnold). I work on this already for a while, but finally I found some time to write about it. Needless to say: It's written in Rust
I'm working in a new wasm framework, Isomorphic compiled DOM message oriented framework. It is an extension of yarte and shares most of the code and it syntax.
In the absence of much, these are the benchmarks results of the proof of concept:
I was expecting to be quiet the whole week but somebody posted on HN regarding broot and here I am, tonight, rushing on the issues which went from 10 to 140 in 2 days...
I'm continuing learning Rust and have finally made it to chapter 10 Generic Types, Traits and Lifetimes of the Rust book. This is all a pretty steep learning curve for me, so wish me luck!
This is a pretty neat project. My friend recently told me about the PBRT book too. I've been getting curious about graphics stuff lately so I might look into the book in the future. Supposedly Knuth thinks the book is great because it teaches concepts through 'literate programming'.
Thanks. And don't forget that there is a free copy of the book on the Internet: