You can make this a lot faster assuming the schema is fixed, and clean it up a bit with iterators. IE something like this

    #[derive(Copy,Clone,Deserialize)]
    struct Point {
        x: f64, 
        y: f64, 
        z: f64
    }

    #[derive(Copy,Clone,Deserialize)]
    struct Schema {
        coordinates: Vector<Point>
    }

    fn main() -> Result<(), Box<dyn Error>> {
        let mut json_content = String::new(); 

        File::open("1.json")? // don't need Path 
            .read_to_string(&mut json_content)?;

        let schema = serde_json::from_str::<Schema>(&json_content)?;
 
        let len = schema.coordinates.length(); 
        let (x, y, z) = 
            schema.coordinates
                  .iter()
                  .fold((0.0, 0.0, 0.0), 
                    |(xsum, ysum, zsum), (x, y, z)|{
                        (xsym + x, ysum + y, zsum + z)
                    }); 
        println!("x: {}, y: {}, z: {}", x / len, y / len, z / len);
      Ok(())
    }

While I appreciate the intent, that’s turning beautiful concise code into a very much less readable... thing.

How much faster is that?

It would be more polite and accurate to express that as your opinion rather than objective fact. Personally, I prefer to read the second version. I also expect the techniques shown in it, especially parsing against a type-level schema, would be less error-prone than the original in a larger program.

Haven’t benchmarked but in principle:

Serde is one of the fastest deserializers out there. It excels when it has a defined schema to decode, using the #[derive] syntax should offload the work of the deserializer immensely and negate the effects of looking up fields which may not exist.

As well, using rust’s iterator adaptors like fold can allow the compiler to make better optimizations for things like summing vectors of floats, such as SIMD/auto vectorizing easier. It’s also better at eliminating or reducing bounds checks.

Using iterator abstractions is much more “beautiful” in my opinion to for loops, as well in rust tends to generate better assembly than indexing into collections like slices and vectors.

Yes, you can do the same optimizations in Crystal, and Nim. Someone should write these and post the code for comparison.

FYI you can read directly from a file without reading into a buf first. This might be a bit faster:

    let json_file = File::open(json_file_path).expect("file not found");
    let deserialized_camera: SomeDataType =
        serde_json::from_reader(json_file).expect("error while reading json");

A year ago I did some benchmarks and found that from_reader is much slower than from_slice. There's now a note in the serde_json docs, so it still seems to be an issue.

I guess std::fs::read + serde_json::from_slice is the fastest way to do it, because it avoids the from_reader slowness and an UTF-8 validation.

Thanks for the info, good to know!