#Rust

I like to think of myself as a programming language geek. But then I read something like this[1] from @graydon , and I understand I know pretty much nothing.

[1]: https://graydon2.dreamwidth.org/307291.html

#rust

Taggart :donor:

https://youtu.be/fSJYkgSsIUg

Part 2 of DLL Hijacking in Rust! In which we exploit Windows Defender (!) and introduce a new tool for easy process injection in #Rust.

#InfoSec #CyberSecurity

Oro "it's flatpak time" 🏳️‍🌈

Fixed a bug where #distrobox wouldn't see the container name when passed to my program. It was being saved as a Vector<String>, and passed through to the terminal emulator as several args. So, I joined them all together and passed it through as one, and it Just Works. Nice.

Still trying to figure out how to manage my configuration files, loading them in from the filesystem and putting them into a struct specifically.

#Rust #Rustlang

Kat Marchán 🐈

Still warms my cold gay heart whenever I see a nice looking error report rendered with #miette 😌😌😌#rust

Shane Celis

https://graydon2.dreamwidth.org/307291.html #rust

This is a surprising write up from a popular programming language designer.

♫ You can’t always get what you want… ♫

Alice I Cecile

https://github.com/bevyengine/bevy/pulls?q=is%3Aopen+is%3Apr+label%3AS-Ready-For-Final-Review+-label%3AS-Controversial+-label%3AS-Blocked+-label%3AS-Adopt-Me+

Another Monday, another #bevymergetrain. Despite the maintainers' best efforts to merge things as we see them we have 9 PRs in the backlog today! Follow along to see how the #opensource #rust #gamedev sausage is made.

Crab project be like

🦀 Effective Rust: 35 Specific Ways To Improve Your Rust Code
➥ David Drysdale

#Rust #RustLang
https://www.lurklurk.org/effective-rust/

jbz :catjam:

🦀The #Rust I Wanted Had No Future @graydon
"The Rust We Got is many, many miles away from The Rust I Wanted. I mean, don't get me wrong: like the result. It's great. I'm thrilled to have a viable C++ alternative, especially one people are starting to consider a norm, a reasonable choice for day-to-day use. I use it and am very happy to use it in preference to C++. But!
There are so, so many diferences from what I would have done, if I'd been "in charge" the whole time" https://graydon2.dreamwidth.org/307291.html

Sisuaika

Spent all afternoon trying to get #linux installed on my old 2015 #chromebook so I'd have something to practice #rust and #rustlings on while I travel next week.

Unfortunately, my chromebook went end-of-life before the linux mode was added. When I finally got it running via crouton on a dated version of Ubuntu (that I can't upgrade without breaking) I realized that....

... the battery was non-functional.

A monkey throws a computer off their desk in frustration.

https://rustwasm.github.io/docs/wasm-bindgen/

@Jdreben @guardiarris @maegul Yes, at least #Leptos takes the #SolidJS approach of using signals to update only the minimal amount of DOM that actually changes.

Regarding JS: you don't need to touch it explicitly in those frameworks, BUT: it is still used to manipulate the #DOM.

For this to work, a lib called wasm-bindgen is used (awesome piece of technology!), which basically bridges #Rust <-> #JS:

leptos_dom depends on it:
https://github.com/leptos-rs/leptos/blob/4ade062cd8cdbe9128aa7a2c8169c17c9d3e874c/leptos_dom/Cargo.toml#L28

#RustLang #WASM

Andy Balaam

https://diode.zone/w/kfQs6Hx6asJ8sqmqPbbfGQ

Writing a tiny parser for our Arnie bot:

(recording of the live stream)
#matrix #rust #coding

Jeff Martin

Any #Rust #Cryptography people out there? :blobcatwave:

I've been using the Rust OpenSSL bindings for a while now, and they're fine. They're fine.

But the lib seems to be missing any bindings for EVP_PKEY_pairwise_check() and I'd really like to use it. Support for OpenSSL v3.x apis seems to be generally lacking.

Although, I've heard OpenSSL isn't a great library in general and maybe I should try to use something else. So maybe this is a good opportunity to migrate to a better lib?

What are the good crypto libraries out there for Rust? I'm looking for implementations of basic stuff like RSA, HMAC, AES, etc. Bonus points if the implementation is actually in a memory-safe language (like Rust!).

Ring looks nice maybe? I suppose there are probably bindings for libsodium somewhere. What are people using these days?

Alex Nedelcu ☕️

https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html

This post highlights #Rust's priorities well.

The inventor of the language would have wanted tail calls (TCO), but the feature was ultimately rejected due to performance, linking and ABI concerns. The language targets C/C++ developers, so the argument is that tail calls can be replaced with loops, which work well, even if not elegant.

Turns out there's a cost to the “zero cost abstractions” design philosophy.

Andy Balaam

https://andybalaam.uk.to/

Live streaming in 27 minutes! Writing a Matrix bot in Rust that simulates Arnold Schwarzenegger.

This time: writing a tiny parser to process arnie commands.

#matrix #rust #programming #live #owncast

Guillaume Gomez

https://crates.io/crates/geos

Just published the 8.3.0 version of the geos crate.

It prevents the compute_voronoi function to panic by adding new variants in the geos::Error enum.

#rust #rustlang

juliettef

New IconFontCppHeaders support for Pictogrammers Material Design icons MDI https://pictogrammers.com/library/mdi/

https://github.com/juliettef/IconFontCppHeaders is a zlib C & C++ headers, C# & Python classes, Rust files and Go package for icon fonts:
- Font Awesome
- Fork Awesome
- Google Material Design
- Pictogrammers Material Design icons
- Kenney game icons
- Fontaudio
- Codicons

Thanks Bobby Angelov for the MDI implementation and our patrons https://www.patreon.com/enkisoftware?filters[tag]=IconFontCppHeaders

#GameDev #OSS #Icon #Font #Cpp #Rust #Golang #python #Csharp

mmoya

"During my visit at PyCon recently it was impossible to miss the fact that a number of Python projects are rewriting their core in Rust for performance reasons. #Rust and #Python seem to be best friends." https://groups.google.com/g/beancount/c/vPK7aJsJ8EM/m/Y-vDJ8qDBwAJ

Sisuaika

Wow! I'm absolutely in love with the learning environment of #rust / #rustlang and #rustlings and #rustbyexample. What an incredible combo.

I wish I had a similar environment to learn #python or #julialang in.

For those who are unfamiliar, Rustlings is an interactive learn-by-fixing program you run in your terminal. It correlates directly with Rust's official guide (The Book). They even link together and to the docs. So cool!

https://docs.rs/match-commutative

It's here! 🎉

Announcing match-commutative | A #Rust macro that helps matching on patterns commutatively, reducing the use of duplicated patterns. ✨

This can be useful, if you need to match on `(operant1, op, operant2)`, where `op` builds a commutative relation between `operant1` and `operant2`.

Please see the docs for the actual use case and an example:

Tagging @rjacobson and @tuck, because they've been interested in this. 😉

#RustLang #Crates #CrateTip

"#Rust developers usually are not just looking for "less buggy".

They are addicted to the clicky sound of legos." - by @Amirography in this thread:
https://floss.social/@Amirography@fosstodon.org/110486392843897963

Urgh, this quote is so 100% true!😄

Thank you @Amirography for expressing this!

#RustLang #Quote

blake shaw

I think the biggest problem with #rust is that it's novel enough that its not the kind of thing the average #cpp developer can jump into and figure out as they go along. You gotta read a book, and getting good means writing lots of it. And most c++ developers aren't using c++ because they love it, they're using it because it pays. So the challenge is getting them excited to spend their free time training for what could hypothetically one day be their next job.

❦

https://drewdevault.com/2020/01/04/Slow.html

Here's a blog post benchmarking compilers by “Hello, World!” and Ruby didn't fare well.

#MastoDev #FediDev #Programming #Assembly #Zig #C #Rust #Go #Java #Python #Ruby #Permacomputing

Oro "it's flatpak time" 🏳️‍🌈

I see what people were talking about when they say #Rust is hard to get going for a new project. I've got the idea set up, but I have to get it all implemented and it's a bit of a pain.

Definitely like this more than #C or #Python though, the compiler is a great help.

#rustlang

❦

The decision to use Ruby for Mastodon was a poor choice, to put it mildly.

The diagram below shows relative energy consumption, with values normalized to the most efficient one. So C, as the most energy efficient, has the value 1.

#MastoDev #FediDev #Programming #C #Rust #CPP #Java #Lisp #Haskell #Go #JavaScript #Python #Ruby #Permacomputing

The diagram shows relative energy consumption, with values normalized to the most efficient one. So C, as the most energy efficient, has the value 1.

Paul Chambers

#rust #Windows #Microsoft

'30 year old code killed! Microsoft rewrites Windows kernel with 180,000 lines of Rust'

The latest Windows 11 Insider Preview release is the first to include the programming language Rust.

https://medium.com/@Aaron0928/30-year-old-code-killed-microsoft-rewrites-windows-kernel-with-180-000-lines-of-rust-f891c95959f2

James Dreben

I regularly use and love #Typescript. I used to use #Python the most – it’s what I learned in and I am more interested in backends than frontends. I also am regularly using and really enjoying #Kotlin (so much better than #Java). But truly Typescript is bae.

#Julia is a joy to work with. Very much like Python but more powerful. If it had the library support Python or #JVM has I would probably prefer to use Julia for backends.

But Typescript really changed the game and now that’s probably my favorite language not just because of the language itself but because it has web dominance. Until I can write #WASM with Python or Kotlin or Rust, and I’m building #web applications, TS is my lingua franca.

I want to try #Rust because it’s the new hotness.

Jelmer

I wrote down some notes about porting large #Python projects to #rust: https://www.jelmer.uk/port-py-to-rust.html

Anders Borch

Ok. So the #rust leadership may have failed miserably lately, but the community is very, very awesome!

I just complained about not being able to get my code to compile and not being able to make sense of the error messages.

So many people came to my help, so very quickly!

@nul @Aissen @mvgrim @Hemera thank you! You rock!

Anders Borch

So... I've been trying to port some code to #rust for two weeks now, and as far as I can tell, either the compiler doesn't actually work, or all the docs are flat out lying. I'm at my wits end here.

Looking at Redis: https://docs.rs/redis/latest/redis/

Literally quoting the docs:

let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let mut con = client.get_async_connection().await?;
con.set("key1", b"foo").await?;

Ok cool. Let me put this in a function:

pub async fn set() {
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let mut con = client.get_async_connection().await;
con.set("key1", b"foo").await;
}

This gives me:

error[E0599]: the method `set` exists for enum `Result<Connection<Pin<Box<dyn AsyncStream + Send + Sync>>>, RedisError>`, but its trait bounds were not satisfied
--> src/my_file.rs:37:9
|
37 | con.set("key1", b"foo").await;
| ^^^ method cannot be called due to unsatisfied trait bounds
|
::: /$HOME/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/result.rs:503:1
|
503 | pub enum Result<T, E> {
| ---------------------
| |
| doesn't satisfy `_: AsyncCommands`
| doesn't satisfy `_: ConnectionLike`
|
= note: the following trait bounds were not satisfied:
`Result<redis::aio::Connection<Pin<Box<dyn AsyncStream + std::marker::Send + Sync>>>, RedisError>: redis::aio::ConnectionLike`
which is required by `Result<redis::aio::Connection<Pin<Box<dyn AsyncStream + std::marker::Send + Sync>>>, RedisError>: AsyncCommands`
note: the method `set` exists on the type `redis::aio::Connection<Pin<Box<dyn AsyncStream + std::marker::Send + Sync>>>`
--> /$HOME/.cargo/registry/src/index.crates.io-6f17d22bba15001f/redis-0.23.0/src/commands/mod.rs:66:1
|
66 | / implement_commands! {
67 | | 'a
68 | | // most common operations
69 | |
... |
1861 | | }
1862 | | }
| |_^
= note: this error originates in the macro `implement_commands` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider using `Result::expect` to unwrap the `redis::aio::Connection<Pin<Box<dyn AsyncStream + std::marker::Send + Sync>>>` value, panicking if the value is a `Result::Err`
|
37 | con.expect("REASON").set("key1", b"foo").await;
| +++++++++++++++++

Ok. Cool. It tells me to add an .expect() to unwrap the connection (which doesn't make sense because it isn't optional, but we'll ignore that for now. After adding that expect I get:

error[E0698]: type inside `async fn` body must be known in this context
--> src/my_file.rs:37:20
|
37 | con.expect("").set("key1", b"foo").await;
| ^^^ cannot infer type for type parameter `RV` declared on the method `set`
|
note: the type is part of the `async fn` body because of this `await`
--> src/cache/mod.rs:37:39
|
37 | con.expect("").set("key1", b"foo").await;
| ^^^^^^

WTF?!?!

What can't the compiler understand about a static str?

Why did it allegedly work for the crate authors but doesn't work for me?

And it gets worse, because it's not just for the Redis crate. I spent a week getting sqlx to compile after reading their docs and finding out that there was little no no relation between when was in the docs and what actually compiled.

If I leave rust then it's not because of the leadership, but because the docs simply does not include working code out of the box.

#Community #Shoutout #Rustacean

Shout-out to all the #Rust'aceans who are not that publicly visible in the interwebz, but doing amazing work for the whole #RustLang community! 🥳

You guys are awesome! 🎡

Bojan

Sometimes #rust doesn't let you hold `&mut self.foo` and `&self.bar` at the same time, which can be frustrating when you know those two fields have nothing to do with each other.

I always just clone and move on, but TIL `std::mem::take` can also help if these objects are big. Just remember to put back the thing tou took :)

jimleonardo

#dotnet #csharp I saw someone mention somewhere they were using an alternative static site generator to Jekyll that was done in .net. Anyone got any good recommendations? I like Jekyll, but have little cause to program in ruby so would like same thing but built using csharp if there is something good. #python or #rust are also viable alternatives for me.

In my 4 years of #RustLang, I've never written any macros, because I didn't felt the need to learn them and I honestly felt a little intimidated by them. 😳

But holy cow have I missed out on this feature! #Rust's (Declarative) Macros can be _really_ useful!

I might put the one I'm currently implementing up on crates.io in the next few days. 🤞 The macro is able to simplify pattern matching in certain scenarios.

Stay tuned! :ferris:

https://ast-grep.github.io/

Another crucial aspect in this matter of #AI rewriting your code:
You should make your tools reusable, so that others can benefit from it as well. This is not possible with #LLMs. Sure you can share the prompt, but the output is all wishy-washy.

Use a proper tool for this kind of task, e.g. ast-grep - ⚡ A fast and polyglot tool for code searching, linting, rewriting at large scale. Written in #Rust:

#RustLang #Code #DevTool #CodeTool #Programming

Jens Reimann

If a Rust frontend application panics, as a user, you see nothing. Only dead buttons. Only the developer console reveals that something is wrong.

Fixed that: Failing in style, with a new crate: https://github.com/ctron/browser-panic-hook/

#rust #wasm

Screenrecord of a demo with the new panic hook. First the existing behavior, following by the new one when the panic hook is set.

Chris Gioran

I sure hope nothing dramatic happened to the governance of my favorite programming language while i was on vacation...

#rust

Esteban K�ber :rust:

This seems like a great learning resource for #Rust #RustLang if you want to understand the lower level behavior of the language's high level constructs
https://eventhelix.com/rust/

PointyFluff

#rust #programming #toast

@mo8it

RFC Proposal 😜

Request `std::toasted::Toast`
a container for type <Butter> or <Jam> or <PB> etc..

probably might need an `std::toaster`

I need more surly toast in my life.

😠 🍞

Jeff Martin

https://blog.rust-lang.org/2023/06/01/Rust-1.70.0.html

Oooh, #Rust 1.70 is stable and adds OnceCell and OnceLock. :blobcatcheer:

Finally! A stabilized way to handle non-const static initialization without needing extra crates like lazy_static!

Super useful for caching one-time setup info needed by tests that's too expensive to recompute for every test.

Like RSA key generation. Oof, that one is slow.

👆 Rustaceans will like this!

> This is what a crab looks like, and apparently what _peak performance_ might look like [...]

> When a _trait_ appears [...]

> Their diversity makes it tricky to _pin_ down [...]

Why is #RustLang so "punnable" (is that a word?)?😅

Sorry, @laurahelmuth if you have no idea of what I'm talking about. It's a joke in the #Rust programming language community.

Ian Kluft ✅🖥️📡

#Rust🦀 1.70.0 released by Rust Language Release Team - sparse by default for crates-dot-io, OnceCell & OnceLock stabilized, is_terminal on fds, named levels of debug info, enforced stability in test CLI https://blog.rust-lang.org/2023/06/01/Rust-1.70.0.html #RustLang #OpenSource #cybersecurity #software #engineering #tech

Axel Rauschmayer

Interesting discussion about editors for Rust code: https://www.reddit.com/r/rust/comments/13xe2ao/thoughts_about_zed_editor/
#Rust #RustLang

Adrian Tombu 🌱

#rust #rustlang #FediHire

I'll be available starting July, so if you know someone that is hiring full-remote Rust freelances/contractors and is not scared away by me working a 4-day week, let's get in touch 🙌

More info on my LinkedIn post: https://www.linkedin.com/feed/update/urn:li:activity:7069959518486417409/

std::usr::baer 🍪:garfield: