{"id":1123,"date":"2020-10-11T10:21:33","date_gmt":"2020-10-11T17:21:33","guid":{"rendered":"http:\/\/dtrace.org\/blogs\/bmc\/?p=1123"},"modified":"2020-10-11T10:21:33","modified_gmt":"2020-10-11T17:21:33","slug":"rust-after-the-honeymoon","status":"publish","type":"post","link":"https:\/\/bcantrill.dtrace.org\/2020\/10\/11\/rust-after-the-honeymoon\/","title":{"rendered":"Rust after the honeymoon"},"content":{"rendered":"

Two years ago, I had a blog entry describing falling in love with Rust<\/a>. Of course, a relationship with a technology is like any other relationship: as novelty and infatuation wears off, it can get on a longer term (and often more realistic and subdued) footing — or it can begin to fray. So well one might ask: how is Rust after the honeymoon?<\/p>\n

By way of answering that, I should note that about a year ago (and a year into my relationship with Rust) we started Oxide<\/a>. On the one hand, the name was no accident — we saw Rust playing a large role in our future. But on the other, we hadn’t yet started to build in earnest, so it was really more pointed question than assertion: where might Rust fit in a stack that stretches from the bowels of firmware through a hypervisor and control plane and into the lofty heights of REST APIs?<\/p>\n

The short answer from an Oxide perspective<\/a> is that Rust has proven to be a really good fit — remarkably good, honestly — at more or less all layers of the stack. You can expect much, much more to come from Oxide on this (we intend to open source more or less everything we’re building), but for a teaser of the scope, you can see it in the work of Oxide engineers: see Cliff’s blog<\/a>, Adam and Dave’s talk on Dropshot<\/a>, Jess on using Dropshot within Oxide<\/a>, Laura on Rust macros<\/a>, and Steve Klabnik on why he joined Oxide<\/a>. (Requisite aside: we’re hiring<\/a>!)<\/p>\n

So Rust is going really well for us at Oxide, but for the moment I want to focus on more personal things — reasons that I personally<\/i> have enjoyed implementing in Rust. These run the gamut: some are tiny but beautiful details that allow me to indulge in the pleasure of the craft; some are much more profound features that represent important advances in the state of the art; and some are bodies of software developed by the Rust community, notable as much for their reflection of who is attracted to Rust (and why) as for the artifacts themselves. It should also be said that I stand by absolutely everything I said two years ago<\/a>; this is not as a replacement for that list, but rather a supplement to it. Finally, this list is highly incomplete; there’s a lot to love about Rust and this shouldn’t be thought of as any way exhaustive!<\/p>\n

1. no_std<\/tt><\/h3>\n

When developing for embedded systems — and especially for the flotilla of microcontrollers that surround a host CPU on the kinds of servers we’re building at Oxide — memory use is critical. Historically, C has been the best fit for these applications just because it so lean: by providing essentially nothing other than the portable assembler that is the language itself, it avoids the implicit assumptions (and girth) of a complicated runtime. But the nothing that C provides reflects history more than minimalism; it is not an elegant nothing, but rather an ill-considered nothing that leaves those who build embedded systems building effectively everything themselves — and in a language that does little to help them write correct software.<\/p>\n

Meanwhile, having been generally designed around modern machines with seemingly limitless resources, higher-level languages and environments are simply too full-featured to fit into (say) tens of kilobytes or into the (highly) constrained environment of a microcontroller. And even where one could cajole these other languages into the embedded use case, it has generally been as a reimplementation, leaving developers on a fork that isn’t necessarily benefiting from development in the underlying language.<\/p>\n

Rust has taken a different approach: a rich, default standard library but also<\/i> a first-class mechanism for programs to opt out of that standard library. By marking themselves as no_std<\/a>, programs confine themselves to the functionality found in libcore<\/a>. This functionality, in turn, makes no system assumptions — and in particular, performs no heap allocations. This is not easy for a system to do; it requires extraordinary discipline by those developing it (who must constantly differentiate between core functionality and standard functionality) and a broad empathy with the constraints of embedded software. Rust is blessed with both, and the upshot is remarkable: a safe, powerful language that can operate in the highly constrained environment of a microcontroller — with binaries every bit as small as those generated by C. This makes no_std<\/tt> — as Cliff has called it<\/a> — the killer feature of embedded Rust, without real precedence or analogue.<\/p>\n

2. {:#x?}<\/tt><\/h3>\n

Two years ago, I mentioned that I love format!<\/tt>, and in particular the {:?}<\/tt> format specifier. What took me longer to discover was {:#?}<\/tt>, which formats a structure but also pretty-prints it (i.e., with newlines and indentation). This can be coupled with {:#x}<\/tt> to yield {:#x?}<\/tt> which pretty-prints a structure in hex<\/i>. So this:<\/p>\n

\n    println!(\"dumping {:#x?}\", region);\n<\/pre>\n
Becomes this:<\/p>\n
\ndumping Region {\n    daddr: Some(\n        0x4db8,\n    ),\n    base: 0x10000,\n    size: 0x8000,\n    attr: RegionAttr {\n        read: true,\n        write: false,\n        execute: true,\n        device: false,\n        dma: false,\n    },\n    task: Task(\n        0x0,\n    ),\n}\n<\/pre>\n
My fingers now type {:#x?}<\/tt> by default, and hot damn is it ever nice!<\/p>\n
3. Integer literal syntax<\/h3>\n
Okay, another small one:  I love the Rust integer literal syntax!  In hardware-facing systems, we are often expressing things in terms of masks that ultimately map to binary.  It is beyond me why C thought to introduce octal and hexadecimal but not binary in their literal syntax; Rust addresses this gap with the same “0b<\/tt>” prefix as found in some non-standard C compiler extensions<\/a>.  Additionally, Rust allows for integer literals to be arbitrarily intra-delimited with an underscore character.  Taken together, this allows for a mask consisting of bits 8 through 10 and bit 12 (say) to be expressed as 0b0000_1011_1000_0000<\/tt> — which to me is clearer as to its intent and less error prone than (say) 0xb80<\/tt> or 0b101110000000<\/tt>.<\/p>\n
And as long as we’re on the subject of integer literals:  I also love that the types (and the suffix that denotes a literal’s type) explicitly encode bit width and signedness.  Instead of dealing with the implicit signedness and width of char<\/tt>, short<\/tt>, long<\/tt> and long long<\/tt>, we have u8<\/tt>, u16<\/tt>, u32<\/tt>, u64<\/tt>, etc.  Much clearer!<\/p>\n
4. DWARF support<\/h3>\n
Debugging software — and more generally, the debuggability of software systems — is in my marrow; it may come as no surprise that one of the things that I personally have been working on is the debugger for a de novo<\/i> Rust operating system that we’re developing.  To be useful, debuggers need help from the compiler in the way of type information — but this information has been historically excruciating to extract, especially in production systems.  (Or as Robert phrased it concisely years ago<\/a>: “the compiler is the enemy.”) And while DWARF<\/a> is the de facto<\/i> standard, it is only as good as the compiler’s willingness to supply it.<\/p>\n
Given how much debuggability can (sadly) lag development, I wasn’t really sure what I would find with respect to Rust, but I have been delighted to discover thorough DWARF support.  This is especially important for Rust because it (rightfully) makes extensive use of inlining; without DWARF support to make sense of this inlining, it can be hard to make any sense of the generated assembly.  I have been able to use the DWARF information to build some pretty powerful Rust-based tooling — with much promise on the horizon.  (You can see an early study for this work in Tockilator<\/a>.)<\/p>\n
5.  Gimli and Goblin<\/h3>\n
Lest I sound like I am heaping too much praise on DWARF, let me be clear that DWARF is historically acutely painful to deal with.  The specification (to the degree that one can call it that) is an elaborate mess, and the format itself seems to go out of its way to inflict pain on those who would consume it.  Fortunately, the Gimli crate<\/a> that consumes DWARF is really good, having made it easy to build DWARF-based tooling.  (I have found that whenever I am frustrated with Gimli, I am, in fact, frustrated with some strange pedantry of DWARF — which Gimli rightfully refuses to paper over.)<\/p>\n
In addition to Gimli, I have also enjoyed using Goblin<\/a> to consume ELF.  ELF — in stark contrast to DWARF — is tight and crisp (and the traditional C-based tooling for ELF is quite good), but it was nice nonetheless that Goblin makes it so easy to zing through an ELF binary.<\/p>\n
6.  Data-bearing enums<\/h3>\n
Enums — that is, the “sum” class of algebraic types — are core to Rust, and give it the beautiful error handling that I described falling in love with two years ago.  Algebraic types allow much more than just beautiful error handling, e.g.  Rust’s ubiquitous Option<\/tt> type<\/a>, which allows for sentinel values to be eliminated from one’s code — and with it some significant fraction of defects.  But it’s one thing to use these constructs, and another to begin to develop algebraic types for one’s own code, and I have found the ability for enums to optionally bear data to be incredibly useful.  In particular, when parsing a protocol, one is often taking a stream of bytes and turning it into one of several different kinds of things; it is really, really nice to have the type system guide how software should consume the protocol.  For example, here’s an enum that I defined when parsing data from ARM’s Embedded Trace Macrocell signal protocol<\/a>:<\/p>\n
\n#[derive(Copy, Clone, Debug)]\npub enum ETM3Header {\n    BranchAddress { addr: u8, c: bool },\n    ASync,\n    CycleCount,\n    ISync,\n    Trigger,\n    OutOfOrder { tag: u8, size: u8 },\n    StoreFailed,\n    ISyncCycleCount,\n    OutOfOrderPlaceholder { a: bool, tag: u8 },\n    VMID,\n    NormalData { a: bool, size: u8 },\n    Timestamp { r: bool },\n    DataSuppressed,\n    Ignore,\n    ValueNotTraced { a: bool },\n    ContextID,\n    ExceptionExit,\n    ExceptionEntry,\n    PHeaderFormat1 { e: u8, n: u8 },\n    PHeaderFormat2 { e0: bool, e1: bool },\n}\n<\/pre>\n
That variants can have wildly different types (and that some can bear data while others don’t — and some can be structured, while others are tuples) allows for the type definition to closely match the specification, and helps higher-level software consume the protocol correctly.<\/p>\n
7.  Ternary operations<\/h3>\n
In C, the ternary operator<\/a> allows for a terse conditional expression that can be used as an rvalue, e.g.:<\/p>\n
\n\tx = is_foo ? foo : bar;\n<\/pre>\n
This is equivalent to:<\/p>\n
\n\tif (is_foo) {\n\t\tx = foo;\n\t} else {\n\t\tx = bar;\n\t}\n<\/pre>\n
This construct is particularly valuable when not actually assigning to an lvalue, but when (for example) returning a value or passing a parameter.  And indeed, I would estimate that a plurality — if not a majority — of my lifetime-use of the ternary operator has been in arguments to printf<\/a>.<\/p>\n
While Rust has no ternary operator per se<\/i>, it is expression-oriented<\/a>: statements have values.  So the above example becomes:<\/p>\n
\n\tx = if is_foo { foo } else { bar };\n<\/pre>\n
That’s a bit more verbose than its C equivalent (though I personally like its explicitness), but it really starts to shine when things can marginally more complicated:  nested ternary operators get gnarly in C, but they are easy to follow as simple nested if-then-else statements in Rust. And (of course) match<\/tt> is an expression as well — and I found that I often use match<\/tt> where I would have used a ternary operator in C, with the added benefit that I am forced to deal with every case.  As a concrete example, take this code that is printing a slice of little-endian bytes as an 8-bit, 16-bit, or 32-bit quantity depending on a size<\/tt> parameter:<\/p>\n
\n    print!(\"{:0width$x} \",\n        match size {\n            1 => line[i - offs] as u32,\n            2 => u16::from_le_bytes(slice.try_into().unwrap()) as u32,\n            4 => u32::from_le_bytes(slice.try_into().unwrap()) as u32,\n            _ => {\n                panic!(\"invalid size\");\n            }\n        },\n        width = size * 2\n    );\n<\/pre>\n
For me, this is all of the power of the ternary operator, but without its pitfalls!<\/p>\n
An interesting footnote on this: Rust once had<\/i> the C-like ternary operator, but removed it<\/a>, as the additional syntax didn’t carry its weight<\/a>.  This pruning in Rust’s early days — the idea that syntax should carry its weight by bringing unique expressive power — has kept Rust from the fate of languages that suffered from debilitating addictions to new syntax and concomitant complexity overdose; when there is more than one way to do it<\/a> for absolutely everything, a language becomes so baroque as to become write-only<\/a>!<\/p>\n
8. paste!<\/tt><\/h3>\n
This is a small detail, but one that took me a little while to find.  As I described in my blog entry two years ago, I have historically made heavy use of the C preprocessor.  One (arcane) example of this is the ##<\/tt> token concatenation operator<\/a>, which I have needed only rarely — but found essential in those moments.  (Here’s a concrete example<\/a>.)  As part of a macro that I was developing, I found that I needed the equivalent for Rust, and was delighted to find David Tolnay’s paste crate<\/a>.  paste!<\/tt> was exactly what I needed — and more testament to both the singular power of Rust’s macro system and David’s knack for build singularly useful things with it!<\/p>\n
9. unsafe<\/tt><\/h3>\n
A great strength of Rust is its safety — but something I also<\/i> appreciate about it is the escape hatch offered via unsafe<\/tt><\/a>, whereby certain actions are permitted that are otherwise disallowed.  It should go without saying that one should not use unsafe<\/tt> without good reason — but such good reasons can and do exist, and I appreciate that Rust trusts the programmer enough to allow them to take their safety into their own hands.  Speaking personally, most of my own uses of unsafe<\/tt> have boiled down to accesses to register blocks on a microcontroller:  on the one hand, unsafe because they dereference arbitrary memory — but on the other, safe by inspection.  That said, the one time I had to write unsafe code that actually<\/i> felt dangerous (namely, in dealing with an outrageously unsafe C library<\/a>), I was definitely in a heightened state of alert!  Indeed, my extreme caution around unsafe code reflects how much Rust has changed my disposition: after nearly three decades working in C, I thought I appreciated its level of unsafety, but the truth is I had just become numb to it; to implement in Rust is to eat the fruit from the tree of knowledge of unsafe programs — and to go back to unsafe code is to realize that you were naked all along!<\/p>\n
10.  Multi-platform support<\/h3>\n
When Steve Klabnik joined Oxide, we got not only an important new addition to the team, but a new platform as well: Steve is using Windows as his daily driver, in part because of his own personal dedication to keeping Rust multi-platform.  While I’m not sure that anything could drive me personally to use Windows (aside: MS-DOS robbed me of my childhood), I do strongly believe in platform heterogeneity.  I love that Rust forces the programmer to really think about implicitly platform-specific issues:  Rust refuses to paper over the cracks in computing’s foundation for sake of expediency.  If this can feel unnecessarily pedantic (can’t I just have a timestamp?!), it is in multi-platform support where this shines:  software that I wrote just… worked on Windows.  (And where it didn’t, it was despite Rust’s best efforts: when a standard library gives you first-class support to abstract the path separator, you have no one to blame but yourself if you hard-code your own!)<\/p>\n
Making and keeping Rust multi-platform is hard work for everyone involved; but as someone who is currently writing Rust for multiple operating systems (Linux, illumos<\/a> and — thanks to Steve — Windows) and multiple ISAs (e.g., x86-64, ARM Thumb-2), I very much appreciate that this is valued by the Rust community!<\/p>\n
11. anyhow!<\/tt> + RUST_BACKTRACE<\/tt><\/h3>\n
In my original piece, I praised the error handling of Rust, and that is certainly truer than ever: I simply cannot imagine going back to a world without algebraic types for error handling.  The challenge that remained was that there were several conflicting crates<\/a> building different error types and supporting routines, resulting in some confusion as to best practice.  All of this left me — like many — simply rolling my own via Box<dyn Error><\/tt>, which works well enough, but it doesn’t really help a thorny question: when an error emerges deep within a stack of composed software, where did it actually<\/i> come from?<\/p>\n
Enter David Tolnay (again!) and his handy anyhow!<\/tt> crate<\/a>, which pulls together best practices and ties that into the improvements in the std::error::Error<\/tt> trait<\/a> to yield a crate that is powerful without being imposing.  Now, when an error emerges from within a stack of software, we can get a crisp chain of causality, e.g.:<\/p>\n
\nreadmem failed: A core architecture specific error occurred\n\nCaused by:\n    0: Failed to read register CSW at address 0x00000000\n    1: Didn't receive any answer during batch processing: [Read(AccessPort(0), 0)]\n<\/pre>\n
And we can set RUST_BACKTRACE<\/tt> to get a full backtrace where an error actually originates — which is especially useful when a failure emerges from a surprising place, like this one from a Drop implementation in probe-rs<\/a>:<\/p>\n
\nStack backtrace:\n   0: probe_rs::probe::daplink::DAPLink::process_batch\n   1: probe_rs::probe::daplink::DAPLink::batch_add\n   2: ::read_register\n   3: probe_rs::architecture::arm::communication_interface::ArmCommunicationInterface::read_ap_register\n   4: probe_rs::architecture::arm::memory::adi_v5_memory_interface::ADIMemoryInterface::read_word_32\n   5: <probe_rs::architecture::arm::memory::adi_v5_memory_interface::ADIMemoryInterface as probe_rs::memory::MemoryInterface>::read_word_32\n   6: ::get_available_breakpoint_units\n   7: <core::iter::adapters::ResultShunt<I> as core::iter::traits::iterator::Iterator>::next\n   8: <alloc::vec::Vec as alloc::vec::SpecFromIter>::from_iter\n   9: ::drop\n  10: core::ptr::drop_in_place\n  11: main\n  12: std::sys_common::backtrace::__rust_begin_short_backtrace\n  13: std::rt::lang_start::{{closure}}\n  14: core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once\n  15: main\n  16: __libc_start_main\n  17: _start) })\n<\/pre>\n
12. asm!<\/tt><\/h3>\n
When writing software at the hardware\/software interface, there is inevitably some degree of direct machine interaction that must be done via assembly.  Historically, I have done this via dedicated .s files<\/a> — which are inconvenient, but explicit.<\/p>\n
Over the years, compilers added the capacity to drop assembly into C, but the verb here is apt:  the resulting assembly was often dropped on its surrounding C like a Looney Tunes anvil, with the interface between the two often being ill-defined, compiler-dependent or both.  Rust took this approach at first too, but it suffered from all of the historical problems of inline assembly — which in Rust’s case meant being highly dependent on LLVM implementation details.  This in turn meant that it was unlikely to ever become stabilized, which would relegate those who need inline assembly to forever be on nightly Rust.<\/p>\n
Fortunately, Amanieu d’Antras took on this gritty problem, and landed a new asm!<\/tt> syntax<\/a>.  The new syntax is a pleasure to work with, and frankly Rust has now leapfrogged C in terms of ease and robustness of integrating inline assembly!<\/p>\n
13. String continuations<\/h3>\n
Okay, this is another tiny one, but meaningful for me and one that took me too long to discover.  So first, something to know about me:  I am an eighty column purist.  For me, this has nothing to do with punchcards or whatnot, but rather with type readability<\/a>, which tends to result in 50-100 characters per line — and generally about 70 or so.  (I would redirect rebuttals to your bookshelf, where most any line of most any page of most any book will show this to be more or less correct.)  So I personally embrace the “hard 80”, and have found that the rework that that can sometimes require results in more readable, better factored code.  There is, however, one annoying exception to this: when programmatically printing a string that is itself long, one is left with much less horizontal real estate to work with!  In C, this is a snap: string literals without intervening tokens are automatically concatenated, so the single literal can be made by multiple literals across multiple lines.  But in Rust, string literals can span multiple lines (generally a feature!), so splitting the line will also embed the newline and any leading whitespace.  e.g.:<\/p>\n
\n    println!(\n        \"...government of the {p}, by the {p}, for the {p},\n        shall not perish from the earth.\",\n        p = \"people\"\n    );\n<\/pre>\n
Results in a newline and some leading whitespace that represent the structure of the program, not the desired structure of the string:<\/p>\n
\n...government of the people, by the people, for the people,\n        shall not perish from the earth.\n<\/pre>\n
I have historically worked around this by using the concat!<\/tt> macro to concatenate two (or more) static strings, which works well enough, but looks pretty clunky, e.g.:<\/p>\n
\n    println!(\n        concat!(\n            \"...government of the {p}, by the {p}, for the {p}, \",\n            \"shall not perish from the earth.\"\n        ),\n        p = \"people\"\n    );\n<\/pre>\n
As it turns out, I was really overthinking it, though it took an embarrassingly long time to discover:  Rust has support for continuation of string literals!  If a line containing a string literal ends in a backslash, the literal continues on the next line, with the newline and any leading whitespace elided<\/i>.  This is one of those really nice things that Rust lets us have; the above example becomes:<\/p>\n
\n    println!(\n        \"...government of the {p}, by the {p}, for the {p}, \\\n        shall not perish from the earth.\",\n        p = \"people\"\n    );\n<\/pre>\n
So much cleaner!<\/p>\n
14. --pretty=expanded<\/tt> and cargo expand<\/tt><\/h3>\n
In C — especially C that makes heavy use of the preprocessor — the -E<\/tt> option can be invaluable:  it stops the compilation after the preprocessing phase and dumps the result to standard output.  Rust, as it turns out has an equivalent in the --pretty=expanded<\/tt> unstable compiler option.  The output out of this can be a little hard on the eyes, so you want to send it through rustfmt<\/tt> — but the result can be really enlightening as to how things actually work.  Take, for example, the following program:<\/p>\n
\nfn main() {\n    println!(\"{} has been quite a year!\", 2020);\n}\n<\/pre>\n
Here is the --pretty=expanded<\/tt> output:<\/p>\n
\n$ rustc -Z unstable-options --pretty=expanded year.rs | rustfmt --emit stdout<\/b>\n#![feature(prelude_import)]\n#![no_std]\n#[prelude_import]\nuse std::prelude::v1::*;\n#[macro_use]\nextern crate std;\nfn main() {\n    {\n        ::std::io::_print(::core::fmt::Arguments::new_v1(\n            &[\"\", \" has been quite a year!\\n\"],\n            &match (&2020,) {\n                (arg0,) => [::core::fmt::ArgumentV1::new(\n                    arg0,\n                    ::core::fmt::Display::fmt,\n                )],\n            },\n        ));\n    };\n}\n<\/pre>\n
As an aside, format_args!<\/tt><\/a> is really magical — and a subject that really merits its own blog post from someone with more expertise on the subject.  (Yes, this is the Rust blogging equivalent of Chekhov’s gun!) <\/p>\n
With so many great David Tolnay crates, it’s fitting we end on one final piece of software from him: cargo expand<\/a> is a pleasant wrapper around --pretty=expanded<\/tt> that (among other things) allows you to only dump a particular function.<\/p>\n
The perfect marriage?<\/h2>\n
All of this is not to say that Rust is perfect; there are certainly some minor annoyances (rustfmt: looking at you<\/a>!), and some forthcoming features that I eagerly await (e.g., safe transmutes, const generics).  And in case it needs to be said: just because Rust makes it easier to write robust software doesn’t mean that it makes it impossible to write shoddy software!<\/p>\n
Dwelling on the imperfections, though, would be a mistake.  When getting into a long-term relationship with anything — be it a person, or a company, or a technology — it can be tempting to look at its surface characteristics:  does this person, or company or technology have attributes<\/i> that I do or don’t like?  And those are important, but they can be overemphasized: because things change over time, we sometimes look too much at what things are<\/i> rather than what guides them<\/i>.  And in this regard, my relationship with Rust feels particularly sound:  it feels like my values and Rust’s values<\/a> are a good fit for one another — and that my growing relationship with Rust will be one of the most important of my career!<\/p>\n","protected":false},"excerpt":{"rendered":"
Two years ago, I had a blog entry describing falling in love with Rust. Of course, a relationship with a technology is like any other relationship: as novelty and infatuation wears off, it can get on a longer term (and often more realistic and subdued) footing — or it can begin to fray. So well […]<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"_links":{"self":[{"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/posts\/1123"}],"collection":[{"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/comments?post=1123"}],"version-history":[{"count":0,"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/posts\/1123\/revisions"}],"wp:attachment":[{"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/media?parent=1123"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/categories?post=1123"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bcantrill.dtrace.org\/wp-json\/wp\/v2\/tags?post=1123"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}