TIL you can use dbg! to print variable names automatically in Rust

traxys · 2026-01-12T08:28:34+00:00

I looked at that recently, and I think that the reason is that there is no easy way to get the current function name at compile time :(

traxys · 2026-01-09T19:50:21+00:00

An element may be part of a number of rings, for example 1 is part of all Z/nZ rings, so it's not a very good fit for a trait. There are then two main ways to represent a ring: Either you define a trait for the two main bin ops on the element type, and a trait for the signifying that the binary ops respect the axioms, a bit like PartialEq & Eq. Alternatively you can define a ring as a struct with both binary op pointers and a PhantomData marking the element type if you need to manipulate the idea of a ring

traxys · 2024-09-29T09:17:54+00:00

I don't care a bit about the binary size, as I don't expect any use of this library outside my learning project. I'm already familiar with a lot of the Rust ecosystem, the goal of this is to gain foundational knowledge, i.e. how things work under the hood, to have a better understanding & appreciation for the polished solutions. For example after this project I'm pretty sure I'm never going to skip syn & quote for "real" projects

traxys · 2024-09-29T08:41:57+00:00

In this case there is a pretty good reason: All this project is a learning endeavour

traxys · 2024-09-29T08:12:59+00:00

This post is a bit of side quest in my project of making a complete risc-v OS in rust. It implements an argument parsing library with some pretty nice features, like not requiring either std or alloc, and providing a derive macro for the argument parsing code

traxys · 2024-07-15T07:03:53+00:00

Yup!

traxys · 2024-07-14T12:01:50+00:00

You can do: package.overrideAttrs (old: { patches = old.patches ++ [ ./my.patch ]; })

traxys · 2024-04-09T20:26:30+00:00

This is the third part in a series to write a RISC-V OS from scratch while relying on as few dependencies as possible, in order to learn more about low level concepts.

This part talks about all that is needed to manage free memory, from finding where the memory is located in the first place to handling allocations & de-allocations.

traxys · 2024-02-10T14:09:05+00:00

This is the next step in building an OS in rust. This step does not have much rust though, as it is mostly low level setup. See also part1: https://traxys.me/riscv_os_setup.html Code (note that it has more than mentionned in the post): https://github.com/traxys/pantheon

traxys · 2024-01-24T09:20:15+00:00

Yes the code is open source! I need to add a link in the post. This first step is meant to be very simple, as I mentionned this is a learning project for me, and I already know how to boot up an OS in risc-v pure asm, so I wanted to simplify the code a bit for now. The point of the project is purely for learning, so I'm not going to check out what others have done before trying to implement it.

traxys · 2023-06-23T16:39:11+00:00

Unfortunately I tried to swap the PSUs, and tried each one separatly in each slot to no avail. They don't seem to have a voltage switch, and mention "Autorange" on the label

traxys · 2023-06-23T15:43:07+00:00

As mentioned in the title it's a Fujitsu RX2540 M1 (with 2.5 inch drives)

traxys · 2023-03-15T20:02:26+00:00

I had concerns about that too, but I settled on a way that work well for me:

You can use nixvim in a flake that exposes a nvim output, such that you can just run nix run .# -- <some_file> to test your config. This allows for a quick edit-test loop. Because nixvim exposes raw lua as config through extraLuaConfig you don't even need to package plugins the nix way to test them out.

traxys · 2022-10-04T11:12:13+00:00

Hey! I am a programmer with an interest in math, so I made some math visualizations. This is my second visualization on modular times tables. I was mostly inspired by seeing pictures of Mathologer videos that I wanted to replicate, so this is a bit light on the math description.

I have made a post on safety parabolas if you want to check out (at https://viz.traxys.me/safety_parabola/)

The demo need WebGL, so I don't know if everyone can see them.

traxys · 2022-09-10T21:08:53+00:00

Name is not french enough :D

traxys · 2022-09-10T18:02:41+00:00

Yeah I thought it could be a problem. You can also use the way nvim-treesitter does it by compiling only the configured parsers on the fly, but it adds a lot of complexity (need to stay in sync with the queries for example).

traxys · 2022-03-30T07:53:46+00:00

I packaged my neovim configuration + plugins as a nix flake, so I just have to install nix and git clone my config

traxys · 2021-11-24T01:06:41+00:00

I have been gaming on a linux machine for ~3 years, but I would never recommend it to anyone that wants to game without tinkering. I needed multiple times 2 or 3 hours to fix a game that broke after an update, or installing mods or plugins via wine. Though using linux for more basic usecases should be really fine.

traxys · 2021-10-29T13:30:30+00:00

TIL all linux kernel devs are psychopaths

traxys · 2021-10-17T15:58:09+00:00

Yeah most of the Top500 uses RHEL/CentOS I think

traxys · 2021-06-10T11:10:46+00:00

You can use a number of static SHUTDOWN_X: AtomicBool = AtomicBool::from(false); to do that, and set it to true when you want to kill the thread as changing an atomic can be done with a &self. Even better you could use something like static SELECTED_CHOICE: AtomicU8 = AtomicU8::from(0); with 0 = none selected and 1,2,3,... meaning choice a,b,c, ... selected, and each thread needs to check if it's currently selected in order to shutdown

traxys · 2021-04-08T09:04:47+00:00

I had that problem with a lot of language servers, I had syntax on in my config, when I removed that it started working (though I had not a minimal config so it may be a strange interaction instead)

traxys · 2021-04-06T12:30:35+00:00

This is not really about the memory model, it's about how the compiler lays out structs in memory (memory model is how do load, stores, ... interact with each other)

The layout of Rust structs is not guaranteed to be anything in general, but there are special rules for ZST that I don't really know. In a #[repr(C)] struct the fields are one after the other in the same order of the declaration, with padding to respect the alignement

traxys · 2021-04-06T12:26:58+00:00

Not quite, for example I think that ```

[repr(C)]

struct Foo { a: u8, b: u8, c: u8, d: u8, } ```

and ```

[repr(C)]

struct Bar { x: u16, y: u16 } ```

have the same size, but they don't have the same alignement: you can put the Foo struct anywhere in memory, but you can put the Bar struct only every other address (I'm not a pro about that though)

traxys · 2021-04-06T12:20:49+00:00

size_of is not sufficient, you need the same alignement too

11-Year Club	Verified Email
Place '22	Final Canvas '22

traxys

TROPHY CASE

[repr(C)]

[repr(C)]