Skip to content

Instantly share code, notes, and snippets.

KodrAus /
Created Apr 11, 2020
Find `msbuild` using `vswhere`
use std::path::PathBuf;
use std::process::Command;
use std::str;
let mut msbuild = PathBuf::from("msbuild");
let check_msbuild = Command::new(msbuild)
use std::{
enum Dyn<'v, T: ?Sized, TStatic: ?Sized>
KodrAus / PureDI.cs
Last active Jan 20, 2020 — forked from davidfowl/PureDI.cs
DI under the hood. This is what DI containers automate for you
View PureDI.cs
using System;
using System.Threading;
namespace PureDI
class Program
static void Main(string[] args)
// Create the singletons once
KodrAus /
Last active Jul 23, 2019
Finding my examples
KodrAus /
Last active Jun 29, 2020
Converting between `tracing` key values and `log` key values
use std::fmt;
use log::kv::{self, Source, value::{self, Fill}};
use tracing::{Value, Field, field::{self, Visit}};
pub struct LogField<'kvs>(&'kvs Field, &'kvs dyn Value);
impl fmt::Debug for LogField<'_> {
KodrAus / Replace Concrete impl with
Created Jan 25, 2019
Using cargo features to replace a set of concrete impls with a blanket one
View Replace Concrete impl with

Using cargo features to replace a set of concrete trait impls with a blanket one

There's subtlety involved in doing this so I've just dumped this out from another document in case I ever need to remember what they were in the future.


The Visit trait can be treated like a lightweight subset of serde::Serialize that can interoperate with serde, without necessarily depending on it. It can't be implemented manually:

/// A type that can be converted into a borrowed value.
union MaybeInitialized<T> {
initialized: T,
uninitialized: (),
KodrAus /
Last active Jun 11, 2018
Properties Macro
This example demonstrates a potential macro for capturing log properties.
The macro uses a syntax that's _similar_ to struct literals. The idea is to support
extensions to the way properties are captured using attributes.
There's a bit of a misalignment between how formatting is communicated in the log
message and the contextual properties, but they are a bit different. Args are slurped
up into the message using the formatting API whereas properties are exposed as data.
View NonRootScopeLifetime.cs
An Autofac lifetime that ensures dependencies are only resolved from scoped containers.
This acts like a safety-net to prevent captive dependencies:
// Register some short-lived dependency using the `NonRootScopeLifetime`
var registration = builder.Register(c => c.Resolve<IStore>().BeginSession()).As<ISession>();
registration.RegistrationData.Lifetime = new NonRootScopeLifetime();

Dependable Dependencies

A dependable API, docs, examples and maintainership supported by tools and resources.

In this post I'd like to explore the quality libraries aspect of the [Rust 2018 roadmap RFC]. I'll lay out the framework that underpins my perspective on open source development as a starting point for conversation.

Quality means dependability. It also means a bunch of other things, but I'd like to focus on dependability here. The roadmap discusses sharpening Rust's offerings in a few focus domains, and I think a key to doing that is by supporting the dependability of libraries that fit within them.

What exactly is dependability though? I think a dependable library consists of: