The Importance of Not Over-Optimizing in Rust

Story time!

Meet Gene!

• Python Developer
• Aggregating JSON
• Heard Rust is faster than Python

            #[derive(Deserialize)]
            struct Data {
                name: String,
                value: u16,
            }
          

            #[derive(Deserialize)]
            struct Data<'a> {
                name: &'a str,
                value: u16,
            }
         

            #[derive(Deserialize)]
            struct Data<'a> {
                name: &'a str,
                value: u16,
            }
          

• Lifetimes
• Generic arguments
• References
• Ownership

          fn parse_json(input: &str) -> Data {
              serde_json::from_str(input).unwrap()
          }
          

          fn parse_json<'a>(input: &'a str) -> Data<'a> {
              serde_json::from_str(input).unwrap()
          }
          

          impl Data {
            ...
          }
          

          impl<'a> Data<'a> {
            ...
          }
          

          struct DataCollection {
              data_values: Vec<Data>,
          }
          

          struct DataCollection<'a> {
              data_values: Vec<Data<'a>>,
          }
          

😃

😕

Did Gene have to learn these things right away?

            fn remove_trailing_spaces(s: String) -> String {
                s.trim_end().to_string()
            }
          

            fn remove_trailing_spaces(s: &str) -> &str {
                s.trim_end()
            }
          

How does Rust Look to New Developers?

Naïve Rust is often "fast enough"

• Become productive faster
• Write code that's faster but not fastest
• Reduce developers leaving community
• Topics are not going anywhere

New Developers

• Use Owned values
• Use .clone()
• Use Rc/Arc
• Compile with --release!

Thank you!