Rust

Rust analyzer and compilation are very slow. My system is heating up, running out of ram and disk space. I have 8 GB ram.

I use helix editor.

edit: thank you for all your suggestions. I am breaking up the project into smaller crates to see if that makes a difference.

I got the biggest improvements from zram and sccache. With zram my memory usage stays at 90% instead of fully running out when rust-analyzer starts.

Hi everyone! I want to introduce a project that I’ve been working on for 6 days with ARandomOSDever. It currently has only a few layout functions: Spacing, Direction (Row, Column), Padding, Margin, Min/Max Size, Align, and it already supports no std. I’m sharing this with you to get feedback, both good and bad. I would really appreciate your thoughts

GitHub repo: https://github.com/dest-hq/axes

Crates: https://crates.io/crates/axes

I’m not entirely sure, yet why Axes performs faster than Taffy, maybe it’s because Taffy has many layout functions that affect performance.

Here’s a benchmark (Axes 0.2.0 vs Taffy 0.9.2).

| Benchmark | Axes | Taffy | Difference | |

|

|

|

| | Tree: 1,000 Nodes | 15.889 µs | 89.114 µs | 139.472% | | Tree: 10,000 Nodes | 1.1744 ms | 1.0698 ms | 4.45988% | | Tree: 100,000 Nodes | 8.7379 ms | 33.083 ms | 116.426% | | Compute: 1,000 Nodes | 17.423 µs | 39.317 µs | 77.1731% | | Compute: 10,000 Nodes | 176.51 µs | 446.35 µs | 86.6455% | | Compute: 100,000 Nodes | 1.7988 ms | 14.976 ms | 157.107% |

Hope you have an awesome day

Developer @mxghj@programming.dev

cross-posted from: https://lemmy.bestiver.se/post/946316

Comments

Id like to share my implementation of the signal protocol that i use in my messaging app. The implementation is in rust and compiles to WASM for browser-based usage.

• Github: https://github.com/positive-intentions/signal-protocol
• Demo: https://signal.positive-intentions.com/

Its far from finished and im not sure when its a good time to share it, but i think its reasonable now.

The aim is for it to align with the official implementation (https://github.com/signalapp/libsignal). That version was not used because my use case required client side browser-based functionality and i struggled to achieve that in the official one where javascript is used but is targeting nodejs.

There are other nuances to my approach like using module federation, which led to me moving away from the official version.

While i have made attempts to create things like audits and formal-proof verication, i am sharing it now if there is feedback about the implementation. Any outstanding issue i may be overlooking? Feel free to reach out for clarity on any details.

This signal implementation is for a p2p messaging app. See it in action here: https://p2p.positive-intentions.com/iframe.html?globals=&id=demo-p2p-messaging--p-2-p-messaging&viewMode=story

We finally have rustup distribution for rustc_codegen_gcc! Now I'll get back to build rustc for a target not currently supported by Rust.

Crossposted from https://lemmy.ml/post/43115912

In this example, all todo operations — from simple CRUD to tasks own instructions — are executed by a virtual machine.

The concept is that any kind of automation or workflow can be enabled by task instructions executed by the VM, rather than hardcoded functions in the app. It’s close to the concept of rules engines.

There are 4 demo task instructions:

• chain - Creates next task once when another completes. Removes calldata after call - called once
• either - Sets complete if either one or another task is completed + deletes not completed task (see gif)
• destructable - task self destructs when it's status set to complete
• hide - Keeps task hidden while specified task's status is not complete.

It is possible to add your own instructions to calldata.toml and use them within todo example:

cargo run -- add <TASK_TITLE > -calldata <INSTRUCTION_NAME> <PARAMETERS>

repo: https://github.com/tracyspacy/spacydo

todo example : https://github.com/tracyspacy/spacydo/tree/main/examples/todo

Kellnr - the open source Rust crate registry - released a new major version. Many month of work went into it. Check it out, if you want to host your own crates or custom toolchains for Rust!

Someone once told me somewhere, that if I am trying to learn rust, I should learn C first, so that I know how to shoot myself in the foot, learning to avoid doing so, so that the borrow checker of rust doesnt seam to unforgiving (since you somewhat know, what happens if you dont follow best practices). So thats what I did (somewhat) for the past 6 months. I wrote some stuff in C, but mainly I had quite of a deep dive into operating systems (mainly linux), working mechanics of memory and the CPU and a lot more (I will try to make a list of the stuff I learned and the ressources used below). My question to you is, if there are any additional concepts/things I should learn beforehand, to start learning rust.

The (somehwat complete) list of things learned for the past 6 months:

• Stack Behaviour (Why its so fast, what its used for,....)
• The heap (why its useful, but dangerous)
• Theoretical Concepts of threading (Concurrency vs. paralellism)
• Theory of race conditions (how and why they occur, and some tricks to avoid them)
• Concepts of Memory allocation on an OS level (Address Spaces)
• System calls and the separation between kernel and user space
• Signals
• Basics of Inter-Process-Communication
• CPU-Scheduling (CPU-/IO-Bursts, context switches, different scheduling algorithms up to ROund RObin (based on complexity))
• How loops, conditions and function calls get implemented in Assembly / how the CPU performs these
• Bitwise Operations

I probably forgot a significant part of the stuff I learned, but its quite hard turning it into a list, without writing a whole book, and trying to remeber everything.
Most of these things are mainly theory, since I havent gotten around to code that much in C. However I definitively have some experience in C. This includes on how to handle pointers, basics of handling the heap, strings (even if I absolutely hate them in C) and some system calls (I played around with sbrk for custom memory management without malloc).

The ressources I used for learning is primarily the YouTube-Channel CoreDumped (I highly recommend), LowLevel and some other ressources, but these were the most helpful ones.

So, feel free to send me down my next rabbit hole before starting rust.

Supac is a declarative package manager written in Rust fully scriptable in nushell. It's meant to make it easy to use the native package managers in existing distros without going through the associated headaches of using Nix, while maintaining the ergonomics of structured data in nushell.

Currently supported backends are:

• Archlinux and derivatives
• flatpak
• cargo/cargo-binstall
• uvx (packages only for now)
• rustup toolchains

I daily drive it, and it works well. Feel free to give it a try!

cross-posted from: https://programming.dev/post/45110642

I hope it's ok to ask for some feedback here. Of not, please let me know. The rules did not sound like against it

I'm very new to Rust. And while in general my coding background is ok, Rust still feels alien to me. I think I'm just still at "how to think in Rust" part of the curve.

So I would like to ask here for opinions on the following bit of code. I know that those unwrap are too optimistic for production, and I could figure out how to pass io::Error from the function all the way up to the shell. But what are other choices that I don't see?
What would you write differently? What looks like Pythonisms/C++isms? Or is missing the mark completely?

use std::{fs, io};  
use std::path::PathBuf;  
use std::convert::TryFrom;  

use clap::Parser;  
use parquet::file::reader::SerializedFileReader;  
use parquet::record;  
use csv::WriterBuilder;  

#[derive(Debug, Parser)]  
#[command(version, about, long_about = None)]  
struct Args {  
    dir: String,  
    #[arg(default_value = "0")]  
    count: usize  
}  

fn get_files_in_dir(dir: &str) -> Option<Vec<PathBuf>>  
{  
    let dir = fs::read_dir(dir);  
    if dir.is_err() {  
        return None  
    };  
    let files = dir.unwrap()  
        .map(|res| res.map(|e| e.path()))  
        .collect::<Result<Vec<_>, _>>();  
    if files.is_err() {  
        return None  
    }  
    files.ok()  
}  

fn read_parquet_dir(entries: &Vec<String>) ->  impl Iterator<Item = record::Row> {  
    entries.iter()  
        .map(|p| SerializedFileReader::try_from(p.clone()).unwrap())  
        .flat_map(|r| r.into_iter())  
        .map(|r| r.unwrap())  
}  
                            
fn main() -> Result<(), io::Error> {  
    let args = Args::parse();  
    let entries = match get_files_in_dir(&args.dir)  
    {  
        Some(entries) => entries,  
        None => return Ok(())  
    };  


    let mut wtr = WriterBuilder::new().from_writer(io::stdout());  
    for (idx, row) in read_parquet_dir(&entries.iter().map(|p| p.display().to_string()).collect()).enumerate() {  
        let values: Vec<String> = row.get_column_iter().map(|(_column, value)| value.to_string()).collect();  
        if idx == 0 {  
            wtr.serialize(row.get_column_iter().map(|(column, _value)| column.to_string()).collect::<Vec<String>>())?;  
        }  
        wtr.serialize(values)?;  
        if args.count>0 && idx+1 == args.count {  
            break;  
        }  
    }  
    
    Ok(())  
}