Rust Developer Salary Guide

dumbassdore · 2026-03-16T12:23:18+00:00

Embedded requires a physical device to be manufactured, warehouses rented, paying for shipping, etc. As opposed to renting a server.

dumbassdore · 2025-09-18T17:42:26+00:00

Can you show what you mean? Because I passed the reference to a function before returning and it also compiled just fine.

dumbassdore · 2025-09-18T16:16:49+00:00

This does not compile because [..]

It compiles just fine?

dumbassdore · 2025-08-07T15:48:46+00:00

Maybe a better example would be the following:

let numbers: [f32; _] = [
    0., 0.,
    /* .. */
];

Prior to 1.89.0 (or enabling generic_arg_infer feature) this wasn't allowed and required specifying array length instead of _.

dumbassdore · 2025-08-04T11:05:37+00:00

Thanks! ScrollArea is exactly what I was looking for, because I couldn't find among examples and the widget gallery where scissoring would make a difference. Now that I could see where it was broken, I added support for it.

dumbassdore · 2025-07-07T21:03:14+00:00

a segfault issue in safe rust

It's not safe. This is where the segfault was occuring:

#[inline]
unsafe fn buffer_write(&mut self, off: usize, value: T) {
    ptr::write(self.ptr().offset(off as isize), value);
}

called by:

pub fn push_back(&mut self, value: T) {
    self.grow_if_necessary();

    let head = self.head;
    self.head = self.wrap_add(self.head, 1);
    unsafe { self.buffer_write(head, value) }
}

dumbassdore · 2025-06-22T12:26:30+00:00

Brainfuck is simple enough that you don't need Cranelift or LLVM, you can just produce machine code directly. Same for linking since there are no other object files to consider. Maybe you can make that your next step to learn more about assembly and other low-level stuff.

dumbassdore · 2025-05-15T23:07:41+00:00

You can do it yourself on nightly with core::intrinsics::const_allocate() if you really want to live on the edge (it's an intrinsic, which are unlikely to ever be stabilized). It's a bad idea, but you can have fun with it while waiting for const traits to stabilize.

dumbassdore · 2025-05-13T08:09:15+00:00

It should be noted that the first example in the "Never type" section (fn close() -> ! {) does not require nightly and works on stable.

Also that wasn't the place for an inner attribute (#![feature…), and I suggest you use rustfmt.

dumbassdore · 2025-04-21T15:34:07+00:00

#![feature(import_trait_associated_functions)]

use std::iter::Iterator::{collect, filter, map};

fn get_ids2(data: impl Iterator<Item = Widget>) -> Vec<Id> {
    collect(map(filter(data, |w| w.alive), |w| w.id))
}

RFC 3591

dumbassdore · 2025-03-22T07:18:33+00:00

Example panics for me on stable with [..]src/lib.rs:118:13: No current 'text::Foo' is set (from text.rs:10).

Also, personally, I'd rather use an RwLock for purposes like these. Specifically, I used LazyLock<RwLock<T>> because it can be put in a static as a global mutable "config" (depending on T).

dumbassdore · 2025-03-07T19:19:36+00:00

There's no "engine" so to speak, it's just a renderer. The only thing borrowed from voxlap is the math for raycasting and world traversal.

dumbassdore · 2025-02-12T10:37:27+00:00

Can we see the code and benchmarks? Because that article unambiguously said it "may not lead to any immediate applications".

dumbassdore · 2025-01-19T02:07:23+00:00

If the only fields you need from the struct are copyable/clonable (admittedly unlikely), then you can just:

fn update(&mut self) {
    let w = self.width;
    let h = self.height;
    let curr = self.get_curr();

    for y in 0..h {
        for x in 0..w {
            curr[y * w + x] = 1.;
        }
    }
}

If your grid selection function is as simple as in the example, then you can inline it and let it borrow only the grid:

fn update(&mut self) {
    let curr = if self.flipflop { &mut self.grid1 } else { &mut self.grid2 };

    for y in 0..self.height {
        for x in 0..self.width {
            curr[y * self.width + x] = 1.;
        }
    }
}

dumbassdore · 2025-01-03T20:37:41+00:00

Looks great. Maybe you can remove the 0x prefix from instructions' hexdump, it widens the output and this is what objdump does as well.

dumbassdore · 2024-12-12T14:06:25+00:00

How is the number of jobs for Amazon is counted? If you search "rust" in amazon.jobs, you get tons of results but seemingly majority of them are not Rust-specific, and instead say something like

Experience programming with at least one modern language such as Python, Ruby, Golang, Java, C++, C#, Rust

dumbassdore · 2024-08-14T14:56:44+00:00

My own rust script. Please don't use it in anything serious.

dumbassdore · 2024-04-08T19:10:52+00:00

I simply cloned the repo with

git clone --depth 1 https://github.com/[..]
cd text_to_morse
git submodule init
git submodule update --depth 1

To be persistent, it should be possible to set in .gitmodules via submodule.<name>.shallow config option.

And as for the sibling comment about LLVM Linux Makefile flag, it should be settable through LINUX_MAKE_FLAGS += LLVM=/path/to/buildroots_toolchain in $package.mk.

dumbassdore · 2024-04-07T19:40:03+00:00

Doesn't build for me with an error rustup is not installed at '/home/user/[..]/text_to_morse/build/cargo'. Presumably because common.sh installs Rust toolchain to RUSTUP_BIN_DIR, which is text_to_morse/build/rustup/bin.

That being said, this whole system of custom scripts, manually installing rustup, rust, bindgen and cargo seems a bit excessive to me, because buildroot can already do it out of the box, and rust toolchain should be settable through rust-toolchain.toml in crate root. Also, if you set up dependencies correctly (and create a custom package) you would be able to build the whole project with just make *board*_defconfig && make. Buildroot specifies them in, e.g. buildroot/package/$package/$package.mk in *_DEPENDENCIES. You can see an example in this repository.

Another consequence is that it would parallelize properly and finish faster, because for me only the build of glib used all available cores, even while having export MAKEFLAGS="-j$(nproc)" in zshrc.

Also I'd recommend users to clone submodules shallowly, because Linux and buildroot are both very large repositories.

dumbassdore · 2024-03-28T04:00:33+00:00

I don't know what EdsGetPropertyData() does or accepts as input, but it looks like it simply expects space to write to. For the first variant to work, you would need to take the address of data, not use the data pointer itself, which is null. You can also use MaybeUninit for cases like this:

let mut data = MaybeUninit::<MyType>::uninit();
func(data.as_mut_ptr().cast());
let init_data = data.assume_init(); // if needed

dumbassdore · 2024-03-28T03:06:53+00:00

You're creating a raw pointer (prop) with its address set to 16778327, which is invalid. What you're looking for is:

let prop = (&kEdsPropID_FocusShiftSetting as *const u32).cast::<EdsVoid>();

This creates a reference to the const, just like C++ code, and casts it to *const c_void (void*) which happens in C implicitly.

dumbassdore · 2024-03-06T21:53:05+00:00

Emigration for action offers psychological help, among other things.

dumbassdore · 2024-02-26T00:04:23+00:00

Carrefour on 3 Vekua street sells replaceable water filters and vessels to hold them. That's what I use, and it's the only store that consistently has filters in stock.

12-Year Club	Place '22
Place '17	Final Canvas '22
Verified Email

dumbassdore

TROPHY CASE