... Und ich hab ein schönes Ziel auf das ich das #learningRust fokussieren kann 😀

Please share your opinions on my learning code parquet2csv

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(()) }
Ah, yet another aspiring "author" 📝 thinks the world needs a #book about #Ruby that it never asked for. But don't worry, it'll be ready sometime before the heat death of the universe. 🚀 Why bother with actual #innovation when you can just repackage the same boring tech jargon with a sprinkle of "I'm learning Rust"? 🙄
https://patshaughnessy.net/2025/11/17/compiling-ruby-to-machine-language #Overload #TechJargon #LearningRust #AspiringAuthors #HackerNews #ngated
Compiling Ruby To Machine Language - Pat Shaughnessy

#rust ggez app i'm writing crashes when I'm on my laptop, but works when I use it with the docking station (which I don't have with me on the train to Nürnberg). Some unresolved wgpu bug: https://github.com/gfx-rs/wgpu/issues/6159

Time to work on something else, I guess...
#learningRust #programming

Panic at unreachable · Issue #6159 · gfx-rs/wgpu

Description Panic at an unreachable in wgpu-core/src/device/global.rs, line 1859: unreachable!("Fallback system failed to choose present mode. This is a bug. Mode: {:?}, Options: {:?}", config.pres...

GitHub

Just wrapped up another Rust project—Minigrep, a command-line file search tool! Feeling accomplished and excited for the next challenge!

😇 If you’re learning Rust, I highly recommend tackling this—it’s a great way to level up!

#RustLang #Coding #SystemsProgramming #LearningRust #Minigrep #DevJourney

Two Years of Rust

Reflections on using Rust professionally for two years.

Fernando Borretti

🚀 Rust Under the Hood hardcover edition is now available! 📚

Dive deep into Rust internals through x86-64 assembly, exploring memory management, compiler optimizations, async state machines, and more.

Get your copy today: https://www.amazon.com/dp/B0DS9M8S13

🔧 Learn how enums, structs, Vtables, SIMD, and async executors work at any level. 🦀💻

#Rust #Programming #RustLang #SystemsProgramming #Books #LearningRust

Amazon.com

That’s it, our short tour of my favorite resources for #LearningRust is finished… It’s now time to start your own project or pick up an open source project you like and contribute to it!

Stay tuned to the @hnsec blog for the third installment of our #OffensiveRust series, in which I’ll explore how to use #Rust for vulnerability research and present my humble contributions to @binarly_io idalib bindings, enabling the development in idiomatic Rust of standalone tools based on Hex-Rays’s IDA Pro.

https://security.humanativaspa.it/tag/rust/

rust Archives - hn security

hn security

As an intermediate-level #Rust developer, what you need are learning resources that can help bring your skills to the next level.

One such resource is “Zero to Production in Rust” by @algo_luca, an introduction to web API backend development that provides excellent coverage of the whole language and its patterns, using a realistic project as a practical example for #LearningRust.

https://www.zero2prod.com/

Other intermediate-level learning resources that I recommend are “Effective Rust”, “Rust Design Patterns”, “Rust API Guidelines”, and the “Rust Cookbook”.

Zero To Production In Rust

A hands-on introduction to backend development in Rust.

Happy new year!

If you have followed my previous advice while #LearningRust, you should be ready for one of my favorite learning resources.

“Learn Rust With Entirely Too Many Linked Lists” is a fun and entertaining read on the intricacies of #Rust (and linked lists) by the same author of the eldritch Rustonomicon. You’re welcome!

https://rust-unofficial.github.io/too-many-lists/

Introduction - Learning Rust With Entirely Too Many Linked Lists

Learning Rust With Entirely Too Many Linked Lists