#rust programming

Early details about the Pixel 10 suggest Google could be making a deeper push toward using the Rust programming language, especially around modem-related components. The shift appears tied to improving security, particularly in lower-level parts of the system that have historically been more vulnerable.

Rust has been gaining traction across the tech industry because it helps reduce common memory-related bugs that can lead to exploits. By applying it to modem software, Google may be trying to strengthen one of the more sensitive areas of a smartphone, where outside connections and data handling are constant.

This move would fit into a broader trend of companies gradually replacing older, risk-prone code with safer alternatives, though it likely won’t mean a complete overhaul overnight. Instead, it’s expected to be a gradual transition focused on critical areas first.

yes it is! :>

i saw panic!("at the disco"); somewhere and thought it was hilarious, so i made it my tumblr title

found a forum post that accurately describes many issues with it

I am trying to learn rust and the syntax is so so painful and annoying compared to RISC-V assembly, why is it so complex? I am clearly doing something fundamentally wrong

with assembly I can look at a 4 page long PDF and know exactly how to do everything, but in rust the fucking "let" command or whatever it is is more complex then VAX why.

but I just implemented an amazing feature for my library, untwine, which is a parser generator macro enabling extremely easy parsing of any format (and it's even capable of doing context-sensitive parsing!).

look at how a boolean parser would be defined before:

this isn't so bad, but it's duplicating the string equality check, so it will check if the string is equal to "true" twice - once when it parses the pattern, and once when converting the data in the code block.

this approach also doesn't scale. in the case where you're matching weekdays, you end up needing a match statement inside your code block:

this gave me the ick for a long time because you have to repeat yourself and you have an ugly unreachable case which will trigger if you ever forget to add a case to the match statement after adding it to the pattern (which is very easy to do).

so now I've implemented a parser type which looks and acts like a match statement, allowing you to express things like that much more elegantly:

it's also extremely handy for command parsing, allowing me to express branching parsing paths that evaluate to the same type very cleanly. you can capture the values of the patterns you parse, which is perfect for grabbing arguments: