For those using CloudFlare to host RSS feeds (like Rust Herald), please don’t set the protection too aggressively. CloudFlare uses ProjectHoneyPot to get a ‘reputation’ score for an IP address, and I’ve been all week trying to resolve what appears to be a false positive against my server IP address from ProjectHoneyPot, most probably (from the tiny amount of information available) due to someone spamming links to my website, although even that much is unclear. The symptoms are the RSS feeds getting blocked with a CAPTCHA. Neither CloudFlare support/community nor ProjectHoneyPot have really helped. People have only suggested various workarounds, like get a new IP address. It was CloudFlare support that suggested getting site owners to change their settings. The experience has been more than a little Kafkaesque.
This summer, I will again work (amongst other things) on a “memory model” for Rust/MIR. However, before I can talk about the ideas I have for this year, I have to finally take the time and dispel the myth that “pointers are simple: they are just integers”. Both parts of this statement are false, at least in languages with unsafe features like Rust or C: Pointers are neither simple nor (just) integers.
I also want to define a piece of the memory model that has to be fixed before we can even talk about some of the more complex parts: Just what is the data that is stored in memory? It is organized in bytes, the minimal addressable unit and the smallest piece that can be accessed (at least on most platforms), but what are the possible values of a byte? Again, it turns out “it’s just an 8-bit integer” does not actually work as the answer.
I hope that by the end of this post, you will agree with me on both of these statements. :)
For some time now (since the 1.26 release, to be precise), Rust has a very powerful machinery for CTFE, or compile-time function evaluation. Since then, there have been various discussions about which operations should be allowed during CTFE, which checks the compiler should do, how this all relates to promotion and which kinds of guarantees we should be able to expect around CTFE. This post is my take on those topics, and it should not be surprising that I am going to take a very type-system centric view. Expect something like a structured brain dump, so there are some unanswered questions towards the end as well.
rpds: Rust Persistent Data Structures v0.5.0 - Now with fast mutable methods
In my last post, I talked about the new “pinned references” which guarantee that the data at the memory it points to will not, ever, be moved elsewhere.
I explained how they enable giving a safe API to code that could previously only be exposed with
unsafe, and how one could go about proving such a thing.
This post is about another application of pinned references—-another API whose safety relies on the pinning guarantees: Intrusive collections.
It turns out that pinned references can almost be used for this, but not quite.
However, this can be fixed by extending the guarantees provided by pinned references, as suggested by @cramertj.
Recently, a new API for “pinned references” has landed as a new unstable feature in the standard library. The purpose of these references is to express that the data at the memory it points to will not, ever, be moved elsewhere. Others have written about why this is important in the context of async IO. The purpose of this post is to take a closer, more formal look at that API: We are going to take a stab at extending the RustBelt model of types with support for pinning.
Rust-webapp-starter : Rust single page webapp written in actix-web with vuejs.
Async stable Actix-web framework
diesel, postgresql r2d2
SPA CORS JWT
- Vuejs Parcel-bundler
actix-web framework is cool tool for rust web tthings !
An in-depth look at shared references and interior mutability: https://www.ralfj.de/blog/2018/01/31/sharing-for-a-lifetime.html
Join us next Monday for your monthly installment of Rust related talks. https://www.meetup.com/Rust-London-User-Group/events/246637221/ #rustlang #ldn
The Rust HTML sanitizer, based on html5ever, is now stable, with an API that allows extensions and performance tuning in the future.
I’ve written an article that answers questions I’ve been asking when I was working with C library from Rust.
Hey, so I’m working lib rust library that can manipulate FreeBSD’s jails, but in order to do so I have to interact with ZFS and in order to do so I must be able to construct Name/Value lists. Turns out it was a good library to learn about FFI wrappers.
https://github.com/Inner-Heaven/libnv-rs Comments very welcome.
There was a piece of non-Rust spam pushed into Rust Herald and subsequently, Twitter.
We deleted the posting and will monitor for other occurrences.
Berlin Rust Meetup on Wednesday, October 18th https://www.meetup.com/Rust-Berlin/events/243485005/