I thought to give it a try, but first I had to make myself familiar with the code and with the tests.

Side note: by the time I started to write this blog post Brendan Molloy, who is apparently the original author of the crate, has already committed the change. So maybe I won't have to do anything here. On the other hand I could contribute some of my expertise to the project (GitHub Actions, testing etc.)

As I looked at the tests I noticed that in many cases the tests seem to only print the generated HTML/XML and don't seem to verify the result. There were several println! calls instead of assert_eq! calls.

I figured it would be an interesting thing to see the test coverage report and the mutation testing report.

SHA

I cloned the repository and got this sha: 89b9f9fa2f729f6e95ec79638c977dfecc3b6ec1. I keep it here so you can check it out too to reproduce this result.

Test coverage report

Using cargo-tarpaulin

cargo install cargo-tarpaulin

$ cargo tarpaulin --out Html --out Stdout

|| Uncovered Lines:
|| src/display.rs: 45-47, 50-52, 55-57, 60-62, 65-67, 135, 139, 293-294, 298, 342-343, 347, 392, 492-495, 497, 537
|| src/document.rs: 25, 49, 51-52, 57, 59-60, 73-74, 77-79, 82-84, 88-92, 99-107, 112-114, 118-125, 129, 175-177, 180, 182-190, 192-193, 197-198, 200-202, 204, 208-209, 214, 217-218, 220-224, 226, 228-229, 231, 234-237, 239, 242-244, 248-253, 257-258, 261-262, 265-269, 272-275, 281, 284-286, 294-297, 301, 318-321, 325-327, 357, 364, 369, 384, 422, 425, 431-433, 450-451, 466-468, 480, 487-489, 512, 527-529, 535-540, 542-544, 556, 563-564, 566-567, 569-570, 572, 574, 576-577, 601, 625-631, 633-634, 636-638, 645-650
|| src/element.rs: 93, 96, 119, 163, 168, 170, 206, 211, 220, 279-282, 284-287, 289, 440, 486, 549-550, 554-555, 558-560, 564-565, 568, 575-576, 578-579, 581, 583, 585-586, 589, 592-593, 595-596, 598, 601-602, 604, 606-607, 610, 617-619, 633
|| src/key.rs: 23-25, 33-35, 43-45, 68, 74-77, 88-91, 95-98, 102-105, 109-112, 116-123
|| src/select.rs: 48, 54-55, 69, 73, 78-79, 104, 108, 139-140, 143-144, 150, 154-155, 158, 162-165, 171-174, 180, 188-189, 192-193, 205, 209-210, 217, 221, 229, 237, 241, 245, 250-252, 256, 261-262, 264-265, 269, 273, 276, 280-281, 284-285, 288-290, 293, 295, 299, 301, 305, 316, 322-323, 346, 355-360, 364-366
|| src/value.rs: 27, 34, 41, 48, 52-55
|| Tested/Total Lines:
|| src/display.rs: 182/212
|| src/document.rs: 145/325
|| src/element.rs: 134/188
|| src/key.rs: 14/52
|| src/select.rs: 37/112
|| src/value.rs: 12/20
||
57.65% coverage, 524/909 lines covered

Mutation testing

Using cargo-mutants

For documentation see the mutants web site.

cargo install cargo-mutants

$ cargo mutants
Found 337 mutants to test
ok       Unmutated baseline in 8s build + 0s test
 INFO Auto-set test timeout to 20s
MISSED   src/display.rs:46:9: replace Config::indent -> Self with Default::default() in 0s build + 0s test
MISSED   src/display.rs:51:9: replace Config::end_pad -> Self with Default::default() in 0s build + 0s test
MISSED   src/display.rs:56:9: replace Config::max_line_length -> Self with Default::default() in 0s build + 0s test
MISSED   src/display.rs:61:9: replace Config::entity_mode -> Self with Default::default() in 0s build + 0s test
MISSED   src/display.rs:66:9: replace Config::indent_text_nodes -> Self with Default::default() in 0s build + 0s test
MISSED   src/display.rs:128:9: replace <impl Print<Config, State<'_>> for Declaration>::print -> std::io::Result<()> with Ok(()) in 0s build + 0s test
MISSED   src/display.rs:222:9: replace + with * in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:221:9: replace + with * in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:223:53: replace + with * in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:223:43: replace + with * in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:223:17: replace + with * in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:226:56: replace > with == in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:226:56: replace > with < in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:226:56: replace > with >= in fmt_attrs in 0s build + 0s test
MISSED   src/display.rs:288:25: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:287:25: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:289:69: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:289:59: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:289:33: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:291:72: replace > with == in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:291:72: replace > with < in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:291:72: replace > with >= in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:333:28: replace match guard !attrs.is_empty() with false in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:337:21: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:336:21: replace + with - in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:336:21: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:338:65: replace + with - in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:338:65: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:338:55: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:338:29: replace + with * in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:340:53: replace && with || in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:340:68: replace > with == in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:340:68: replace > with < in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:340:68: replace > with >= in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 1s test
MISSED   src/display.rs:354:60: replace && with || in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:354:46: replace || with && in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:354:49: delete ! in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:360:49: delete ! in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:379:38: replace || with && in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:379:41: delete ! in <impl Print<Config, State<'_>> for ElementValue>::print in 0s build + 0s test
MISSED   src/display.rs:412:41: replace && with || in <impl Print<Config, State<'_>> for NodeValue>::print in 0s build + 0s test
MISSED   src/display.rs:436:41: replace && with || in <impl Print<Config, State<'_>> for NodeValue>::print in 0s build + 0s test
MISSED   src/display.rs:442:41: replace && with || in <impl Print<Config, State<'_>> for NodeValue>::print in 0s build + 0s test
MISSED   src/display.rs:482:53: replace || with && in process_entities in 0s build + 0s test
MISSED   src/display.rs:486:28: replace || with && in process_entities in 0s build + 0s test
MISSED   src/display.rs:492:49: replace match guard !is_text with true in process_entities in 0s build + 0s test
MISSED   src/display.rs:492:49: replace match guard !is_text with false in process_entities in 0s build + 0s test
MISSED   src/display.rs:493:48: replace match guard !is_text with true in process_entities in 0s build + 3s test
MISSED   src/display.rs:493:48: replace match guard !is_text with false in process_entities in 0s build + 0s test
MISSED   src/display.rs:500:28: replace match guard !ch.is_ascii_whitespace() && ch.is_ascii_control() with false in process_entities in 0s build + 0s test
MISSED   src/display.rs:492:49: delete ! in process_entities in 0s build + 0s test
MISSED   src/display.rs:493:48: delete ! in process_entities in 0s build + 0s test
MISSED   src/display.rs:508:25: replace && with || in process_entities in 0s build + 0s test
MISSED   src/display.rs:508:32: replace == with != in process_entities in 0s build + 0s test
MISSED   src/display.rs:510:33: replace && with || in process_entities in 0s build + 0s test
MISSED   src/display.rs:511:61: replace || with && in process_entities in 0s build + 0s test
MISSED   src/document.rs:83:8: delete ! in ord_elem in 0s build + 0s test
MISSED   src/document.rs:91:16: delete ! in ord_elem in 0s build + 0s test
MISSED   src/document.rs:106:12: delete ! in ord_elem in 0s build + 0s test
MISSED   src/document.rs:124:12: delete ! in ord_elem in 0s build + 0s test
MISSED   src/document.rs:176:9: replace Document::sort_nodes -> Vec<Node> with vec![] in 0s build + 1s test
MISSED   src/document.rs:176:29: replace < with == in Document::sort_nodes in 0s build + 0s test
MISSED   src/document.rs:176:29: replace < with > in Document::sort_nodes in 0s build + 0s test
MISSED   src/document.rs:176:29: replace < with <= in Document::sort_nodes in 0s build + 0s test
MISSED   src/document.rs:208:21: replace && with || in Document::sort_nodes in 0s build + 0s test
MISSED   src/document.rs:208:24: delete ! in Document::sort_nodes in 0s build + 0s test
MISSED   src/document.rs:243:9: replace Document::sort_attrs with () in 0s build + 0s test
MISSED   src/document.rs:249:9: replace Document::sort with () in 0s build + 0s test
MISSED   src/document.rs:258:9: replace Document::set_declaration with () in 0s build + 0s test
MISSED   src/document.rs:262:9: replace Document::declaration -> Option<&Declaration> with None in 0s build + 0s test
MISSED   src/document.rs:266:9: replace Document::set_doctype with () in 0s build + 0s test
MISSED   src/document.rs:295:9: replace Document::doctype -> Option<&str> with None in 0s build + 0s test
MISSED   src/document.rs:295:9: replace Document::doctype -> Option<&str> with Some("") in 0s build + 0s test
MISSED   src/document.rs:295:9: replace Document::doctype -> Option<&str> with Some("xyzzy") in 0s build + 0s test
MISSED   src/document.rs:319:9: replace Document::to_string_pretty_with_config -> String with String::new() in 0s build + 0s test
MISSED   src/document.rs:319:9: replace Document::to_string_pretty_with_config -> String with "xyzzy".into() in 0s build + 0s test
MISSED   src/document.rs:363:25: delete match arm Some(XML_VERSION_1_0) in Document::from_reader in 0s build + 0s test
MISSED   src/document.rs:366:25: delete match arm Some(XML_VERSION_1_1) in Document::from_reader in 0s build + 0s test
MISSED   src/document.rs:626:9: replace <impl fmt::Display for ReadError>::fmt -> fmt::Result with Ok(Default::default()) in 2s build + 2s test
MISSED   src/document.rs:646:9: replace <impl Error for ReadError>::source -> Option<&(dyn Error +'static)> with None in 0s build + 0s test
MISSED   src/element.rs:214:18: replace >= with < in Element::append_new_element_after in 0s build + 0s test
MISSED   src/element.rs:559:9: replace Element::display -> String with String::new() in 0s build + 0s test
MISSED   src/element.rs:559:9: replace Element::display -> String with "xyzzy".into() in 0s build + 1s test
MISSED   src/element.rs:576:9: replace Element::next_sibling_element -> Option<Element> with None in 0s build + 1s test
MISSED   src/element.rs:581:29: replace == with != in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:583:15: replace += with -= in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:583:15: replace += with *= in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:585:18: replace < with == in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:585:18: replace < with > in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:585:18: replace < with <= in Element::next_sibling_element in 0s build + 0s test
MISSED   src/element.rs:593:9: replace Element::prev_sibling_element -> Option<Element> with None in 0s build + 1s test
MISSED   src/element.rs:598:29: replace == with != in Element::prev_sibling_element in 0s build + 0s test
MISSED   src/element.rs:601:18: replace == with != in Element::prev_sibling_element in 0s build + 0s test
MISSED   src/element.rs:604:15: replace -= with += in Element::prev_sibling_element in 0s build + 0s test
MISSED   src/element.rs:604:15: replace -= with /= in Element::prev_sibling_element in 0s build + 0s test
MISSED   src/element.rs:606:18: replace == with != in Element::prev_sibling_element in 0s build + 0s test
MISSED   src/element.rs:618:9: replace Element::query_selector_all -> Vec<Element> with vec![] in 0s build + 0s test
TIMEOUT  src/element.rs:644:15: replace += with *= in walk_tree in 0s build + 20s test
MISSED   src/key.rs:24:9: replace CDataSection::as_str -> &'d str with "" in 0s build + 0s test
MISSED   src/key.rs:24:9: replace CDataSection::as_str -> &'d str with "xyzzy" in 0s build + 0s test
MISSED   src/key.rs:34:9: replace ProcessingInstruction::as_str -> &'d str with "" in 0s build + 0s test
MISSED   src/key.rs:34:9: replace ProcessingInstruction::as_str -> &'d str with "xyzzy" in 0s build + 0s test
MISSED   src/key.rs:44:9: replace Comment::as_str -> &'d str with "" in 0s build + 0s test
MISSED   src/key.rs:44:9: replace Comment::as_str -> &'d str with "xyzzy" in 0s build + 0s test
MISSED   src/key.rs:75:9: replace Node::as_text -> Option<Text> with None in 0s build + 0s test
MISSED   src/key.rs:76:13: delete match arm Node::Text(e) in Node::as_text in 0s build + 0s test
MISSED   src/key.rs:89:9: replace Node::as_document_type -> Option<DocumentType> with None in 0s build + 0s test
MISSED   src/key.rs:90:13: delete match arm Node::DocumentType(e) in Node::as_document_type in 0s build + 0s test
MISSED   src/key.rs:96:9: replace Node::as_cdata -> Option<CDataSection> with None in 0s build + 0s test
MISSED   src/key.rs:97:13: delete match arm Node::CDataSection(e) in Node::as_cdata in 0s build + 0s test
MISSED   src/key.rs:103:9: replace Node::as_comment -> Option<Comment> with None in 0s build + 0s test
MISSED   src/key.rs:104:13: delete match arm Node::Comment(e) in Node::as_comment in 0s build + 0s test
MISSED   src/key.rs:110:9: replace Node::as_processing_instruction -> Option<ProcessingInstruction> with None in 0s build + 0s test
MISSED   src/key.rs:111:13: delete match arm Node::ProcessingInstruction(e) in Node::as_processing_instruction in 0s build + 0s test
MISSED   src/key.rs:117:9: replace Node::to_ordinal -> u8 with 0 in 0s build + 0s test
MISSED   src/key.rs:117:9: replace Node::to_ordinal -> u8 with 1 in 0s build + 0s test
MISSED   src/select.rs:42:5: replace hash -> u32 with 0 in 0s build + 0s test
MISSED   src/select.rs:42:5: replace hash -> u32 with 1 in 0s build + 0s test
MISSED   src/select.rs:49:9: replace <impl Borrow<String> for PrehashedString>::borrow -> &String with Box::leak(Box::new(String::new())) in 0s build + 0s test
MISSED   src/select.rs:49:9: replace <impl Borrow<String> for PrehashedString>::borrow -> &String with Box::leak(Box::new("xyzzy".into())) in 0s build + 0s test
MISSED   src/select.rs:55:9: replace <impl PrecomputedHash for PrehashedString>::precomputed_hash -> u32 with 0 in 0s build + 0s test
MISSED   src/select.rs:55:9: replace <impl PrecomputedHash for PrehashedString>::precomputed_hash -> u32 with 1 in 0s build + 0s test
MISSED   src/select.rs:73:9: replace <impl cssparser::ToCss for Value>::to_css -> std::fmt::Result with Ok(Default::default()) in 0s build + 0s test
MISSED   src/select.rs:79:9: replace <impl PrecomputedHash for Value>::precomputed_hash -> u32 with 0 in 0s build + 0s test
MISSED   src/select.rs:79:9: replace <impl PrecomputedHash for Value>::precomputed_hash -> u32 with 1 in 0s build + 0s test
MISSED   src/select.rs:105:9: replace <impl NonTSPseudoClass for Value>::is_active_or_hover -> bool with true in 0s build + 0s test
MISSED   src/select.rs:109:9: replace <impl NonTSPseudoClass for Value>::is_user_action_state -> bool with true in 0s build + 0s test
MISSED   src/select.rs:144:9: replace <impl selectors::Element for ElementRef<'_>>::parent_element -> Option<Self> with None in 0s build + 0s test
MISSED   src/select.rs:151:9: replace <impl selectors::Element for ElementRef<'_>>::parent_node_is_shadow_root -> bool with true in 0s build + 0s test
MISSED   src/select.rs:159:9: replace <impl selectors::Element for ElementRef<'_>>::is_pseudo_element -> bool with true in 0s build + 0s test
MISSED   src/select.rs:163:9: replace <impl selectors::Element for ElementRef<'_>>::prev_sibling_element -> Option<Self> with None in 0s build + 0s test
MISSED   src/select.rs:172:9: replace <impl selectors::Element for ElementRef<'_>>::next_sibling_element -> Option<Self> with None in 0s build + 0s test
MISSED   src/select.rs:181:9: replace <impl selectors::Element for ElementRef<'_>>::is_html_element_in_html_document -> bool with true in 0s build + 0s test
MISSED   src/select.rs:185:9: replace <impl selectors::Element for ElementRef<'_>>::has_local_name -> bool with true in 0s build + 0s test
MISSED   src/select.rs:189:9: replace <impl selectors::Element for ElementRef<'_>>::has_namespace -> bool with true in 0s build + 0s test
MISSED   src/select.rs:189:9: replace <impl selectors::Element for ElementRef<'_>>::has_namespace -> bool with false in 0s build + 0s test
MISSED   src/select.rs:189:44: replace == with != in <impl selectors::Element for ElementRef<'_>>::has_namespace in 0s build + 0s test
MISSED   src/select.rs:193:9: replace <impl selectors::Element for ElementRef<'_>>::is_same_type -> bool with true in 0s build + 0s test
MISSED   src/select.rs:193:9: replace <impl selectors::Element for ElementRef<'_>>::is_same_type -> bool with false in 0s build + 1s test
MISSED   src/select.rs:193:42: replace == with != in <impl selectors::Element for ElementRef<'_>>::is_same_type in 0s build + 0s test
MISSED   src/select.rs:202:9: replace <impl selectors::Element for ElementRef<'_>>::attr_matches -> bool with true in 0s build + 0s test
MISSED   src/select.rs:206:50: replace match guard ns.as_str() == "" with true in <impl selectors::Element for ElementRef<'_>>::attr_matches in 0s build + 0s test
MISSED   src/select.rs:226:9: replace <impl selectors::Element for ElementRef<'_>>::match_non_ts_pseudo_class -> bool with true in 0s build + 1s test
MISSED   src/select.rs:234:9: replace <impl selectors::Element for ElementRef<'_>>::match_pseudo_element -> bool with true in 0s build + 0s test
MISSED   src/select.rs:238:9: replace <impl selectors::Element for ElementRef<'_>>::is_link -> bool with true in 0s build + 0s test
MISSED   src/select.rs:242:9: replace <impl selectors::Element for ElementRef<'_>>::is_html_slot_element -> bool with true in 0s build + 0s test
MISSED   src/select.rs:250:9: replace <impl selectors::Element for ElementRef<'_>>::has_id -> bool with true in 0s build + 0s test
MISSED   src/select.rs:250:9: replace <impl selectors::Element for ElementRef<'_>>::has_id -> bool with false in 0s build + 0s test
MISSED   src/select.rs:261:9: replace <impl selectors::Element for ElementRef<'_>>::has_class -> bool with true in 0s build + 0s test
MISSED   src/select.rs:261:9: replace <impl selectors::Element for ElementRef<'_>>::has_class -> bool with false in 0s build + 0s test
MISSED   src/select.rs:273:9: replace <impl selectors::Element for ElementRef<'_>>::imported_part -> Option<<Self::Impl as SelectorImpl>::Identifier> with Some(Default::default()) in 0s build + 0s test
MISSED   src/select.rs:277:9: replace <impl selectors::Element for ElementRef<'_>>::is_part -> bool with true in 0s build + 0s test
MISSED   src/select.rs:281:9: replace <impl selectors::Element for ElementRef<'_>>::is_empty -> bool with true in 0s build + 0s test
MISSED   src/select.rs:281:9: replace <impl selectors::Element for ElementRef<'_>>::is_empty -> bool with false in 0s build + 0s test
MISSED   src/select.rs:285:9: replace <impl selectors::Element for ElementRef<'_>>::is_root -> bool with true in 0s build + 0s test
MISSED   src/select.rs:285:9: replace <impl selectors::Element for ElementRef<'_>>::is_root -> bool with false in 0s build + 0s test
MISSED   src/select.rs:285:30: replace == with != in <impl selectors::Element for ElementRef<'_>>::is_root in 0s build + 0s test
MISSED   src/select.rs:289:9: replace <impl selectors::Element for ElementRef<'_>>::first_element_child -> Option<Self> with None in 0s build + 0s test
MISSED   src/select.rs:302:9: replace <impl selectors::Element for ElementRef<'_>>::has_custom_state -> bool with true in 0s build + 0s test
MISSED   src/select.rs:306:9: replace <impl selectors::Element for ElementRef<'_>>::add_element_unique_hashes -> bool with true in 0s build + 0s test
MISSED   src/select.rs:321:9: replace <impl Parser<'i> for TheParser>::parse_non_ts_pseudo_class -> Result<Value, ParseError<'i, SelectorParseErrorKind<'i>>> with Ok(Default::default()) in 0s build + 0s test
MISSED   src/select.rs:353:9: replace Selector::matches -> bool with true in 0s build + 0s test
MISSED   src/value.rs:53:9: replace NodeValue::as_document_type -> Option<&str> with None in 0s build + 0s test
MISSED   src/value.rs:53:9: replace NodeValue::as_document_type -> Option<&str> with Some("") in 0s build + 0s test
MISSED   src/value.rs:53:9: replace NodeValue::as_document_type -> Option<&str> with Some("xyzzy") in 0s build + 0s test
MISSED   src/value.rs:54:13: delete match arm NodeValue::DocumentType(e) in NodeValue::as_document_type in 0s build + 0s test
337 mutants tested in 6m: 165 missed, 118 caught, 53 unviable, 1 timeouts

The 165 missed mutants indicate that there are lots of places the code could be changed and the test would not catch the regression.

Convert println! to assert_eq!

As I mentioned, there were many test cases where at the end of the test the content of the generated document was printed, but not verified. So I changed all those cases. I don't know much about this crate so I could not personally verify the correctness of the results. So first I changed the println to compare the result to an empty string. This made the test fail printing the actual result. Then I took the current actual result and set it as the expected string.

This will ensure that changes to the code don't lead to unplanned changes in the output.

Later someone who wants to manually verify the correctness of the tests can do so.

Here is an example of the changes I made. See the full diff here. It was merged into the code-base.

-   println!("{:#}", doc);
+   assert_eq!("<root>\n  potato\n</root>\n", format!("{:#}", doc));

Running mutation testing again

cargo mutants
...
337 mutants tested in 5m: 141 missed, 142 caught, 53 unviable, 1 timeouts

There are still 141 missed cases, but that's already 24 less than what we had earlier.

Conclusion

Given that the test coverage is "only" 57.65% this might not be such a great example showing that "high test coverage might not mean the code is really tested", but still converting those println! macros to assert_eq! macros reduced the missed cases by 24.

We need to increase the test coverage in order to make sure the code does not accidently breaks in one place when some changes are introduced in another place. At the same time we also need to monitor the reports from the mutant tests to make sure the tests indeed verify the behavior.

Unrelated note: What would be really nice if the two reports could be combined and it would emphasize the statements that were covered by the test coverage, but still don't fail the tests if they are changed.

examples/fixed-start-time/src/main.rs

use std::sync::LazyLock;
use std::time::SystemTime;

static START_TIME: LazyLock<SystemTime> = LazyLock::new(SystemTime::now);

fn main() {
    print_start_time();
    print_start_time();

}

fn print_start_time() {
    println!("{:?}", *START_TIME);
}

Output

examples/fixed-start-time/out.txt

SystemTime { tv_sec: 1781242831, tv_nsec: 637877888 }
SystemTime { tv_sec: 1781242831, tv_nsec: 637877888 }

The nice thing seem to be is creating a dispatch table mapping strings to functions.

Each module is responsible for returning a DispatchTable. There is a central function that combines them.

We could generate this up-front and then pass the DispatchTable to each function but it seemed better to get the DispatchTable internally.

If we do that we'll recreate the DispatchTable in every call. Using the cached crate allows us to eliminate all the calls but the first one.

examples/cache-dispatch-table/src/main.rs

use cached::macros::cached;

mod locations;
mod other;
mod types;

use crate::types::DispatchTable;

fn main() {
    for name in &["city", "state", "country", "language"] {
        process(name);
    }
}

fn process(name: &str) {
    let dispatch = get_dispatch();

    println!("Processing: {name}");
    if let Some(process_fn) = dispatch.get(name) {
        let result = process_fn();
        println!("{}", result);
    }
    println!();
}

#[cached]
fn get_dispatch() -> DispatchTable {
    println!("get_dispatch called");

    let mut config = DispatchTable::new();

    let cfg = crate::locations::get_dispatch();
    for (key, value) in cfg {
        config.insert(key, value);
    }

    let cfg = crate::other::get_dispatch();
    for (key, value) in cfg {
        config.insert(key, value);
    }

    config
}

examples/cache-dispatch-table/src/locations.rs

use crate::types::DispatchTable;

fn process_city() -> &'static str {
    "Processing city of Seoul"
}

fn process_country() -> &'static str {
    "Processing country of Korea"
}

pub(crate) fn get_dispatch() -> DispatchTable {
    println!("get_dispatch for locations called");

    let mut config = DispatchTable::new();
    config.insert("city", process_city);
    config.insert("country", process_country);
    config
}

examples/cache-dispatch-table/src/other.rs

use crate::types::DispatchTable;

fn process_language() -> &'static str {
    "Processing the Korean language"
}

pub(crate) fn get_dispatch() -> DispatchTable {
    println!("get_dispatch for locations called");

    let mut config = DispatchTable::new();
    config.insert("language", process_language);
    config
}

examples/cache-dispatch-table/src/types.rs

use std::collections::HashMap;

pub(crate) type Handler = fn() -> &'static str;
pub(crate) type DispatchTable = HashMap<&'static str, Handler>;

examples/cache-dispatch-table/out.txt

get_dispatch called
get_dispatch for locations called
get_dispatch for locations called
Processing: city
Processing city of Seoul

Processing: state

Processing: country
Processing country of Korea

Processing: language
Processing the Korean language

examples/cache-dispatch-table/Cargo.toml

[package]
name = "cache-dispatch-table"
version = "0.1.0"
edition = "2024"

[dependencies]
cached = "2.0.2"

examples/cache-hashmap-result-of-function/src/main.rs

use std::collections::HashMap;
use cached::macros::cached;

fn main() {
    let config = get_config();
    println!("Config: {:?}", config);

    let config = get_config();
    println!("Config: {:?}", config);
}


#[cached]
fn get_config() -> HashMap<&'static str, String> {
    println!("get_config called");

    let mut config = HashMap::new();
    config.insert("city", String::from("Seoul"));
    config.insert("country", String::from("Korea"));
    config
}

The function runs only once.

examples/cache-hashmap-result-of-function/out.txt

get_config called
Config: {"country": "Korea", "city": "Seoul"}
Config: {"country": "Korea", "city": "Seoul"}

examples/cache-hashmap-result-of-function/Cargo.toml

[package]
name = "cache-hashmap-result-of-function"
version = "0.1.0"
edition = "2024"

[dependencies]
cached = "2.0.2"

Here is the first experiment with it showing how it caches the value in one function, but not in the other. The first 2 tv_nsec values differ, as time have elapsed between the calls. The 3rd and 4th tv_nsec values are the same as the value got cached after the first call.

examples/cache-result-of-function/src/main.rs

use std::time::SystemTime;
use cached::macros::cached;

fn main() {
    let time = get_current_time();
    println!("Current time: {:?}", time);
    let time = get_current_time();
    println!("Current time: {:?}", time);


    let time = get_cached_time();
    println!("Cacehed time: {:?}", time);
    let time = get_cached_time();
    println!("Cacehed time: {:?}", time);
}

fn get_current_time() -> SystemTime {
    SystemTime::now()
}


#[cached]
fn get_cached_time() -> SystemTime {
    SystemTime::now()
}

examples/cache-result-of-function/out.txt

Current time: SystemTime { tv_sec: 1781167332, tv_nsec: 68780987 }
Current time: SystemTime { tv_sec: 1781167332, tv_nsec: 68846651 }
Cacehed time: SystemTime { tv_sec: 1781167332, tv_nsec: 68882989 }
Cacehed time: SystemTime { tv_sec: 1781167332, tv_nsec: 68882989 }

examples/cache-result-of-function/Cargo.toml

[package]
name = "cache-result-of-function"
version = "0.1.0"
edition = "2024"

[dependencies]
cached = "2.0.2"

If you only want to store a timestamp then there are better solutions as well. For example check out the starting time of the process.

[lints.clippy]
cargo        = { priority = -1, level = "deny" }

to Cargo.toml will also turn on the multiple_crate_versions rule.

It will them complain if the same create was added more than once (with different version numbers) to Cargo.lock.

How could this happen?

What to do about it?

1. We can decide to disregard this rule. Add the following line to Cargo.toml

[lints.clippy]
multiple_crate_versions = "allow"

2. Tell Clippy about the specific crates for which we allow the duplication:

Create the clippy.toml file and add the following entry, with the names of the crates we allow to be duplicated:

allowed-duplicate-crates = [
    "async-channel",
    "event-listener",
    "foldhash",
    "hashbrown",
    "hashlink",
    "wit-bindgen",
]

See allowed-duplicate-crates.

3. Figure out which of our dependencies brought in these dependencies and either replace our own dependencies, or send a Pull-Request to our dependencies to allow for more flexibility.

For example when you assign the return value of a function to a variable but you don't explicitely write the type of the variable, Rust will derive (deduct) the type based on the function signature.

If you declare a variable let x = 2;, Rust will derived that it is an i32 and the inlay type hints will show let x: i32 = 2;.

In another case if add together two variables holding numbers (that default to i32) and declare the resulting variable to be i8 then Rust will derived that the original two variables also must be i8.

So

    let x = 2;
    let y = 3;

is understood as

    let x: i32 = 2;
    let y: i32 = 3;

but

    let x = 2;
    let y = 3;
    let z: i8 = x +y;

is understood as

    let x: i8 = 2;
    let y: i8 = 3;
    let z: i8 = x +y;

The inlay type hints will help you understand this.

Inline (inlay) type hints:

I configured the following to make it work. I am not sure everything is really needed.

• Installed rust-analyzers

rustup component add rust-analyzer

• settings.json

In the settings.json file I added the following:

  "inlay_hints": {
    "enabled": true,
  },
  "enable_language_server": true,
  "lsp": {
    "rust-analyzer": {
      "binary": {
        "path": "/home/gabor/.cargo/bin/rust-analyzer"
      },
      "initialization_options": {
        "inlayHints": {
          "maxLength": null,
          "lifetimeElisionHints": {
            "enable": "always",
            "useParameterNames": true,
          },
          "closureReturnTypeHints": {
            "enable": "always",
          },
        },
      },
    },
  },

• Trusted code

Opened the crate I was working on as a "project" and then in the top-left corner of the IDE I clicked on "Trusted project".

Then I could also use Crtl-: to toggle the inline hint.

For example the date and time when it was compiled.

Cargo.toml

We need to add the built crate as a build-time dependency.

examples/embed-build-time-data/Cargo.toml

[package]
name = "embed-build-time-data"
version = "0.1.0"
edition = "2024"

[dependencies]

[build-dependencies]
built = { version = "0.8", features = ["cargo-lock", "dependency-tree", "chrono", "git2", "semver"] }

build.rs

We need to create build.rs in the root of the crate.

examples/embed-build-time-data/build.rs

fn main() {
    built::write_built_file().expect("Failed to acquire build-time information")
}

main.rs

We can then access the data in our code during run-time.

examples/embed-build-time-data/src/main.rs

mod built_info {
    include!(concat!(env!("OUT_DIR"), "/built.rs"));
}

fn main() {
    println!("TARGET                {:?}", built_info::TARGET);
    println!("PKG_VERSION           {:?}", built_info::PKG_VERSION);
    println!("RUSTC_VERSION         {:?}", built_info::RUSTC_VERSION);

    println!("GIT_VERSION           {:?}", built_info::GIT_VERSION);
    println!("GIT_DIRTY             {:?}", built_info::GIT_DIRTY);
    println!("GIT_COMMIT_HASH       {:?}", built_info::GIT_COMMIT_HASH);
    println!(
        "GIT_COMMIT_HASH_SHORT {:?}",
        built_info::GIT_COMMIT_HASH_SHORT
    );

    println!("BUILT_TIME_UTC        {:?}", built_info::BUILT_TIME_UTC);

    println!("CI_PLATFORM           {:?}", built_info::CI_PLATFORM);
}

Output

$cargo run

TARGET                "x86_64-unknown-linux-gnu"
PKG_VERSION           "0.1.0"
RUSTC_VERSION         "rustc 1.93.0 (254b59607 2026-01-19)"
GIT_VERSION           Some("9c6447a")
GIT_DIRTY             Some(true)
GIT_COMMIT_HASH       Some("9c6447a01046142ccf471a597f21d2c08c67c2cd")
GIT_COMMIT_HASH_SHORT Some("9c6447a")
BUILT_TIME_UTC        "Fri, 6 Feb 2026 10:42:50 +0000"
CI_PLATFORM           None

• 00:00 Introduction
• 00:30 Open source contributors are volunteers
• 01:15 How to select an open source project to contribute to?
• 03:30 Select a recently updated project on GitHub.
• 05:08 Rust Digger
• 06:33 A crate that has no repository link... and one that has.
• 09:40 Check the previous Pull-Request adding the repository field to dvb
• 11:05 Picking the spyne-syntax crate.
• 12:40 The GitHub account of Zaid Ahmed, finding the repository of spyne-syntax
• 15:45 Making the change to Cargo.toml, fork the repository
• 17:55 Commit the change, decide on the commit message.
• 20:50 Explain the change on the trailing line.
• 21:50 The issue where I collect the PRs.
• 25:00 We finished the Pull-Request.
• 25:10 Some PRs take time to get accepted.
• 27:40 Offering driver-navigator pair-programming.
• 29:05 Radek: Is there some automatic evaluation of the PR?
• 30:00 GitHub Actions, tests, co-pilot integration.
• 34:45 Karol is volunteering to do a PR.
• 35:50 Karol start sharing his screen.
• 36:54 Picking the kftray-helper crate to work on.
• 38:50 A repository with multiple creates.
• 46:05 CodeRabbit skipped the review.
• 46:30 Google CLA - The legal issues.
• 51:10 Baby steps! Chat with us

1. The user types in an email address (and some other date)
2. The system checks that the looks ok, including the format of the email address. (e.g. that it is not empty)
3. Then it generates a unique code and stores all the received data and the unique code in the database.
4. Then it send an email to the given address containing a URL with the unique code.
5. When the user receives the email and clicks on the link the web system receives this verification request and can update the records marking the email as verified.

There can and probably should be a number of extra things in the process.

• For example the database should contain an expiration date for the code.

The question though, how do you test this code? Do you let the system send out real emails on every run? That would be slow and the test would need to rely an external service that will receive the email from where the test can download it for verification.

One solution for this is to save the email message in a file during the tests and make the tests read that file.

This is what you can see in this similified example.

Cargo.toml

examples/testing-email-sending/Cargo.toml

[package]
name = "mail-sender"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.102"
clap = { version = "4.5.60", features = ["derive"] }
lettre = { version = "0.11.21", features = ["file-transport", "sendmail-transport"] }
uuid = "1.23.1"

main.rs

examples/testing-email-sending/src/main.rs

use clap::Parser;
use lettre::{FileTransport, Message, SendmailTransport, Transport, message::header::ContentType};

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    from: String,

    #[arg(long)]
    to: String,
}

fn main() {
    let args = Cli::parse();

    // We get this from the command line.
    // In a real application it would come from a config file.
    let from = &args.from;

    // This is what the user entered when registering.
    let user_email = args.to.clone();

    register(from, &user_email);
}

fn register(admin_email: &str, user_email: &str) -> String {
    // This code is saved to the database and emailed to the user.
    let code = uuid::Uuid::new_v4().to_string();

    let subject = String::from("Email sent to confirm registration");
    let body = format!("Welcome! Use this code {code} to verify your email address.");

    let email = Message::builder()
        .from(admin_email.parse().unwrap())
        .to(user_email.parse().unwrap())
        .subject(subject)
        .header(ContentType::TEXT_PLAIN)
        .body(body)
        .unwrap();

    if cfg!(test) {
        let dirname = ".";
        let sender = FileTransport::new(dirname);
        let filename = sender.send(&email).unwrap();
        format!("{filename}.eml")
    } else {
        println!("Sending email to {}", user_email);
        let sender = SendmailTransport::new();
        sender.send(&email).unwrap();
        String::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_register_creates_valid_email() {
        let filename = register("admin@example.com", "user@example.com");
        let content = std::fs::read_to_string(filename).unwrap();

        assert!(content.contains("From: admin@example.com"));
        assert!(content.contains("To: user@example.com"));
        assert!(content.contains("Subject: Email sent to confirm registration"));
        assert!(content.contains("Welcome! Use this code"));

        let code_start =
            content.find("Welcome! Use this code ").unwrap() + "Welcome! Use this code ".len();
        let code_end = content.find(" to verify your").unwrap();
        let _code = &content[code_start..code_end];

        // We can then use the code to verify the user in the test.
    }
}

Config test

We can either use

#[cfg(test)]

and

#[cfg(not(test))]

or we can use

if cfg!(test) {
    ...
} else {
    ...
}

examples/mail-sender/Cargo.toml

[package]
name = "mail-sender"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.102"
clap = { version = "4.5.60", features = ["derive"] }
lettre = { version = "0.11.21", features = ["file-transport", "sendmail-transport"] }

examples/mail-sender/src/main.rs

use clap::Parser;
use lettre::{FileTransport, Message, SendmailTransport, Transport, message::header::ContentType};
use std::io::Read;

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    from: String,

    #[arg(long)]
    to: String,

    #[arg(long)]
    subject: String,

    #[arg(long)]
    dir: Option<String>,
}

fn main() {
    let args = Cli::parse();
    let mut body = String::new();
    std::io::stdin().read_to_string(&mut body).unwrap();

    let email = Message::builder()
        .from(args.from.parse().unwrap())
        .to(args.to.parse().unwrap())
        .subject(args.subject)
        .header(ContentType::TEXT_PLAIN)
        .body(body)
        .unwrap();

    match args.dir {
        Some(dirname) => {
            let sender = FileTransport::new(dirname);
            let filename = sender.send(&email).unwrap();
            println!("{filename}.eml");
        }
        None => {
            let sender = SendmailTransport::new();
            sender.send(&email).unwrap();
        }
    }
}

[package]
name = "hash-password"
version = "0.1.0"
edition = "2024"

[dependencies]
argon2 = { version = "0.5.3", features = ["std"] }

examples/hash-password/src/main.rs

use argon2::{
    Argon2,
    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
};
use std::io::{self, Write};

fn main() {
    // Get password from user input
    print!("Enter password to hash: ");
    io::stdout().flush().unwrap();

    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let password = input.trim().as_bytes();

    // Generate a random salt
    let salt = SaltString::generate(&mut OsRng);

    // Initialize Argon2 with default configuration
    let argon2 = Argon2::default();

    // Hash the password
    let password_hash = argon2.hash_password(password, &salt).unwrap();

    println!("\nPassword hash: {}", password_hash);

    // Demonstrate verification
    println!("\nVerifying the password...");
    let hash_string = password_hash.to_string();
    println!("\nPassword hash: {}", hash_string);
    let parsed_hash = PasswordHash::new(&hash_string).unwrap();

    match argon2.verify_password(password, &parsed_hash) {
        Ok(_) => println!("✓ Password verification successful!"),
        Err(_) => println!("✗ Password verification failed!"),
    }
}

This is nice as you won't need to worry about updating it, but it has the obvious disadvantage that the rust compiler automatically changes without you making any change in the configuration.

Many projects use the actions-rs/toolchain, but it has been deprecated on October 13, 2023.

Many use dtolnay/rust-toolchain to set the toolchain(s) explicitely. You can either set a specific version number or you can use the words: stable for the most recent stable version, beta for the next version, nightly for wilde development efforts.

examples/github-workflows/matrix.yml

name: Matrix
on:
  - pull_request
  - push
jobs:
  main:
    strategy:
      matrix:
        rust:
          - stable
          - beta
          - nightly
          - 1.78
          - 1.88
    name: ${{matrix.rust}}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: ${{matrix.rust}}
          components: rustfmt, clippy
      - run: rustup --version
      - run: rustc -vV

      - run: cargo clippy -- --deny clippy::pedantic
      - run: cargo fmt --all -- --check
      - run: cargo test
        #      - run: cargo install cargo-tarpaulin && cargo tarpaulin --out Xml
        #      - uses: codecov/codecov-action@v1

GitHub Actions

Popular GitHub Actions used by Rust Crates.

• dtolnay/rust-toolchain to install the right toolchain(s), target(s), and component(s).

• bnjbvr/cargo-machete to remove unused Rust dependencies

• Swatinem/rust-cache smart caching for rust/cargo projects with sensible defaults to reduce compilation time.

Cargo commands

Various cargo commands I saw in the GitHub Workflows

cargo build --verbose

cargo test --verbose

cargo fmt
cargo fmt -- --check
cargo fmt -- --all --check

cargo clippy
cargo clippy -- --deny clippy::pedantic
cargo clippy --all-targets ${{ matrix.feature }} -- -D warnings
    // where the matrix.feature field can be ['', '--no-default-features', '--all-features']

cargo doc --no-deps --all-features

GitHub Workflow elements

env:
  CARGO_TERM_COLOR: always

Caching with the generic cache action

Using actions/cache (but see the rust-cachec above)

      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-

Verify git tag matches Cargo.toml version

      - name: Verify tag matches Cargo.toml version
        run: |
          TAG_VERSION=${GITHUB_REF#refs/tags/v}
          CARGO_VERSION=$(grep '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')
          echo "Tag version: $TAG_VERSION"
          echo "Cargo.toml version: $CARGO_VERSION"
          if [ "$TAG_VERSION" != "$CARGO_VERSION" ]; then
            echo "Error: Tag version ($TAG_VERSION) does not match Cargo.toml version ($CARGO_VERSION)"
            exit 1
          fi

Publish to crates.io

      - name: Publish to crates.io
        run: cargo publish
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}

Rust en Castellano, en todo de mundo:

• Rust Lang En Español

• GitHub: RustLang en Español - Comunidad de Rustlang en Español
• LinkedIn company: Comunidad de RustLang en Español
• LinkedIn group: RustLang en Español
• Telegram: Programación Rust
• Reddit: r/rustlanges
• Instagram: rustlanges
• X/Twitter
• Mastodon
• YouTube: RustLang en Español
• Twitch: RustLangES

Libros

• El Lenguaje de Programación Rust
• Comprehensive Rust
• Rust en Embedidos
• Rust para C#/.NET Developers
• Rust para Go Developers

Grupos de Meetup

• Busca para los paises hispanohablantes

Argentina

• Rust Argentina (1,135 members) - Buenos Aires

Australia

• Rust Melbourne (1,170 members) - Melbourne

• Rust Sydney (934 members) - Sydney

• Rust Brisbane (450 members) - Brisbane

• Rust Perth Meetup Group (128 members) - Perth

• Canberra Rust User Group (109 members) - Canberra

Austria

• Rust Linz (1,176 members) - Linz

• Rust Vienna (619 members) - Vienna

Belgium

• Belgium Rust user group (238 members) - Brussels

Brazil

• Rust São Paulo Meetup (1,314 members) - São Paulo

• Rust Rio (109 members) - Rio de Janeiro

Canada

AB

• Calgary Rust (30 members) - Calgary

BC

• Vancouver Rust (1,351 members) - Vancouver

ON

• Rust Toronto (648 members) - Toronto
• Rust KW (315 members) - Kitchener

QC

• Rust Montréal (335 members) - Montréal

China

• WebAssembly and Rust Meetup (Wasm Empowering AI) (421 members) - Beijing

• Chengdu (0 members) - Chengdu

Colombia

• Rust Medellin (318 members) - Medellin

• Rust Colombia (155 members) - Medellín

Croatia

• impl Zagreb for Rust (226 members) - Zagreb

Czech Republic

• Rust Prague (448 members) - Prague

• Rust Czech Republic (260 members) - Prague

• Rust Moravia (98 members) - Olomouc

Denmark

• Copenhagen Rust Community (865 members) - Copenhagen

• Rust Aarhus (467 members) - Aarhus

France

• Rust Paris (1,799 members) - Paris

• Montpellier Rust Meetup (315 members) - Montpellier

• Rust Lyon (315 members) - Lyon

• Rust Lille (299 members) - Lille

Georgia

• Rust Tbilisi (151 members) - Tbilisi

Germany

• Rust Berlin (3,435 members) - Berlin

• Rust Munich (1,546 members) - München

• Rust Nuremberg (967 members) - Nürnberg

• Rust Cologne (796 members) - Köln

• Rust Meetup Hamburg (763 members) - Hamburg

• Rust Rhein-Main (296 members) - Darmstadt

• Rust Hack & Learn Karlsruhe (233 members) - Karlsruhe

• Rust - Modern Systems Programming in Leipzig (168 members) - Leipzig

• Rust Frankfurt (117 members) - Frankfurt

• Paessler Rust Camp 2024 (62 members) - Nürnbert

India

• Rust India (2,700 members) - Bangalore

• Rust Delhi (web) (1,446 members) - Delhi

• Rust Language Hyderabad (1,106 members) - Hyderabad

• Rust Pune (565 members) - Pune

Indonesia

• Rust Indonesia (0 members) - Jakarta ?

Ireland

• Rust Dublin (1,086 members) - Dublin

Israel

• Rust TLV (web) (1,343 members) - Tel Aviv-Yafo

Italy

• Rust Language Milano (636 members) - Milano

• Rust Roma (425 members) - Roma

Japan

• Tokyo Rust Meetup (801 members) - Tokyo

Lithuania

• Vilnius Rust and Go Meetup Group (292 members) - Vilnius

Malaysia

• Rust Malaysia (0 members) - Kuala Lumpur

Mexico

• Rust MX (1,192 members) - México City

• Rust Lang Comunidad Mexico (107 members) - Guadalajara

Netherlands

• Rust Nederland (1,883 members) - Amsterdam

• Rust, Getting Started (87 members) - Tiel

• Dutch Rust Meetup (74 members) - Enschede

New Zealand

• Rust Wellington (304 members) - Wellington

• Christchurch Rust Meetup Group (179 members) - Christchurch

Nigeria

• Rust Nigeria (448 members) - Lagos

Norway

• Rust Oslo (1,059 members) - Oslo

• Rust Trondheim (143 members) - Trondheim

Peru

• Perú Rust User Group (58 members) - Lima

Poland

• Rust Wroclaw (887 members) - Wroclaw

• Rust Warsaw (668 members) - Warsaw

• Rust Gdansk (271 members) - Gdansk

• Rust Poland (17 members) - Poznan

Russia

• Rust Moscow (1,519 members) - Moscow

Serbia

• Belgrade Rust Meetup Froup (140 members) - Belgrade

Singapore

• Rust Singapore (309 members) - Singapore

Slovakia

• Bratislava Rust Meetup Group (191 members) - Bratislava

South Africa

• Johannesburg Rust Meetup (953 members) - Johannesburg

South Korea

• Rust Seoul (70 members) - Seoul

Spain

• BcnRust (890 members) - Barcelona

• MadRust (597 members) - Madrid

Sweden

• Stockholm Rust (1,043 members) - Stockholm

• Rust Sthlm (673 members) - Stockholm

• Rust Göteborg (489 members) - Göteborg

Switzerland

• Rust Zurich (1,141 members) - Zürich

• Rust Basel (303 members) - Basel

• Rust Bern (269 members) - Bern

Taiwan

• Rust Taiwan Community (61 members) - Taipei

USA

AZ

• Desert Rust (301 members) - Phoenix

CA

• Rust Bay Area (2,932 members) - San Francisco
• San Francisco Rust Study Group (601 members) - San Francisco
• Rust Los Angeles (546 members) - Los Angeles
• San Diego Rust (493 members) - San Diego
• Mountain View Rust Meetup (257 members) - Mountain View
• Pasadena Thursday Go / Rust (165 members) - Pasadena
• Rust Silicon Valley Community (135 members) - San Jose

CO

• Rust Denver (860 members) - Denver
• Boulder Rust Meetup (169 members) - Boulder

DC

• Rust DC (979 members) - Washington

GA

• Rust Atlanta (377 members) - Atlanta

IL

• Chicago Rust Meetup (509 members) - Chicago

IN

• Indy Rust (403 members) - Indianapolis

MA

• Boston Rust Meetup (1,321 members) - Boston

MI

• Detroit Rust (187 members) - Detroit

MN

• Minneapolis Rust Meetup (542 members) - Minneapolis

MO

• STL Rust (335 members) - Saint Louis

NY

• Rust NYC (web) (3,523 members) - New York
• Buffalo Rust Meetup (475 members) - Buffalo

OH

• Columbus Rust Society (559 members) - Columbus

OR

• PDXRust (826 members) - Portland

TX

• Dallas Rust User Meetup (937 members) - Dallas
• Rust ATX (674 members) - Austin

UT

• Utah Rust (567 members) - Lehi

VA

• Charlottesville Rust Meetup (584 members) - Charlottesville

WA

• Seattle Rust User Group (1,939 members) - Seattle

• Spokane (78 members) - Spokane

Uganda

• Rust Circle Kampala (53 members) - Online

United Kingdom

• Rust London User Group (3,493 members) - London, 17

• Rust and C++ Cardiff (1,147 members) - Cardiff

• Cambridge Rust meetup (491 members) - Cambridge, C3

• Rust and Friends (457 members) - Edinburgh

• Rust Manchester (415 members) - Manchester

• Women in Rust (285 members) - London

• Oxford Rust Meetup Group (262 members) - Oxford, K2

• Reading Rust Workshop (200 members) - Reading

• Rust Belfast Meetup (127 members) - Belfast, R3

Uruguay

• Rust Meetup Uruguay (453 members) - Montevideo

Worldwide

• RustLang en Español (2,305 members) - Online

For this page even the Markdown file is generated. See the preprocessing in the repository and the examples/meetups.yaml file.

It is also a good (or at least reasonable) measurement of the popularity of the language.

The Rust user groups page was updated exactly 6 months ago so today, December 17 is the day I share the new report.

• The report on 2024.12.17.
• The report on 2024.06.17.

Rust User Groups

There are mostly Meetup groups in the list, though some use different platforms. In some cases the number of members cannot be determined.

Overall:

In the last 6 months several groups closed down. Probably due to the price-hike of Meetup (the new price is 3 times of the old one). Some might use another platform, but I don't know where. If you do, please let me know!

These are the groups that were closed:

• Rust Chennai in Chennai, India. 1,204
• Rust AKL in Auckland, New Zealand. 672
• Finland Rust-lang Group in Helsinki, Finland. 602
• Rust-Saar in Saarbrücken, Germany. 425
• Rust Chinese Community in Beijing, China. 163
• Ottawa Rust Language Meetup in Ottawa, ON, Canada. 154
• Hack-away with Rust in Espoo, Finland. 125
• RustSchool Rotterdam in Rotterdam, Netherlands. 104
• Rust Bordeaux in Bordeaux, France. 95
• Rust Triangle in Durham, NC, USA. 89
• Rust Bristol in Bristol, United Kingdom. 86
• Orange County Rust in Irvine, CA, USA. 72
• TOTAL: 3791

the number of members grew only by 2%, but 3,791 were in the closed groups. If we only count the groups that remained open then the growth is 7%. Less than in the previous 6 months, but still impressive.

• In the previous 6 months the number of members grew by 14%. Thats over 30% annually.
• In the 3 months before that the growth was 4.4% or roughly 20% annually.

The three largest Rust groups are:

• Rust NYC (3,523 members. It had 3,192)
• Rust London User Group (3,493 members. It had 3,357)
• Rust Berlin (4,435 members. It had 3,123).

These are also the only groups with more than 3,000 members.

My Code-Mavens group has 3,841 members (up from 3,213). I use it to organize virtual events in English about Rust, Python, and Perl. I did not include it in the list.

The Rust Tel Aviv group that I organize has 1,343 members (up from 1,011 6 months ago and up from 950 members from when I inherited it).

For full details, see of Rust User Groups.

I updated the figures in several commit that will allow someone to check the changes more easily. Here are the commits.

Rust on LinkedIn

Rust on LinkedIn

Rust on Facebook

The first group listed is inactive, but still people become members.

Full report on Rust on Facebook

Rust on Reddit

Subredit members

All 3 groups grow nicely.

See Rust on Reddit

X Twitter

Counting followers

• Orhun Parmaksız is the maintainer of Ratatui.rs.

• Guillaume Gomez, rustdoc team leader, mdbook contributor, Rust Paris organizer.

Instagram

See Rust on Instagram.

Rust on Telegram

There might be other groups, but I am not aware of them and I've just created the Rust Maven telegram group so let me put it here:

Number of members.

And you are invited to join!

If you know of other groups, let me know so I can list them here.

WhatsApp

Are there any Rust groups on WhatsApp that you would like me to include in my report?

The popularity of Rust

The Stack Overflow survey 2024 indicates that Rust is the most admired language by a large gap at 82.2% (the next is Elixir at 76.8%). That is a lot of people love Rust. However this gap was much bigger last year.

On the other hand it is only 6th most desired language with 28.7%. Ahead of it are SQL and HTML/CSS that are, well, different. Also TypeScript, Python, and JavaScript. As I understand this indicates how many job openings are.

In a nutshell, this seem to indicate that many people will want to use Rust, but the number of open positions are relatively low.

However, being on the 6th place is also extremely good.

PYPL - PopularitY of Programming Language

Indicates that Rust is number 8 with 2.97% share and +0.4% trend (up from 9 with 2.66% share and +0.5% 1-year trend six month ago) (up from number 10 twelve months ago)

Python is number 1 with 30.63% share and 1.1% trend. (was 1 with 29.71% share and 1.5% 1-year trend six month ago)

C/C++ (bundled together) is number 4 with 7.02% with +0.7% trend (was number 4 with 7.06% with 0.3% 1-year trend six month ago). (up from number 5 twelve months ago)

TIOBE

Rust is number 18 (dowm from 14 six month ago) (up from number 18 a year ago) with 1.29% ratings and +0.48% change.

Python is number 1 25.87% +10.48% (was 1 with 23.84% ratings and +9.98% change).

C++ is number 2 10.68%, +0.65% (was 2 with 10.82% ratings and 0.81% change.)

C is number 9.47% +0.24% (was 4 with 9.10% ratings and -2.34% change.)

Java is number 4 8.84% +0.44% (was 3 with 9.72% ratings and 1.73% change).

Also on TIOBE:

• ADA jumped from 25 to 11 in 1 year
• Perl jumped from 17 to 13 in 1 year
• R jumped from 21 to 14 in 1 year

Even if earlier you thought that TIOBE is real this can show you that it has some very serious flaws. I doubt ADA and R would jump that much in a year, but I know that nothing in the Perl world explains this surge in Perl. I think I can say that as I am the editor of the Perl Weekly newsletter so I think I have some undertanding about the popularity of Perl.

• Orhun Parmaksız is the maintainer of Ratatui.rs.

• Guillaume Gomez, rustdoc team leader, mdbook contributor, Rust Paris organizer.

2024.06.19

2024.12.16

2025.06.17

• Guest: Herbert Wolverson Rust Trainer/Consultant at Ardan Labs and Chief Product Officer at LibreQoS.

• Host: Gabor Szabo Rust and Python trainer and consultant.

• Language: English

• Location: Zoom