Hi there! 👋

I'm a professional developer from London in the UK. C# is my go-to language these days. My day job typically involves fairly standard enterprise back-end rigamarole - Web APIs, messaging, cloud platforms, databases, and such. My personal time interests tend to be a little more algorithmic in nature, as is hopefully evidenced by the repos you'll find here. Below, you will find a somewhat categorised overview of the most interesting public ones.

• FlUnit: A .NET test framework in which tests are defined with a fluent builder. Higher base level of complexity than method-based frameworks, but makes writing succinct, expressive tests (especially parameterised tests) a breeze. No more "arrange, act, assert" comments needed to clarify your test structure, and no more awkward attribute-based test argument retrieval. I use it for all of my other projects, and while its not exactly taking over the world, download counts on NuGet suggest that at least some other people like it too:
  • FlUnit: The core library.
  • FlUnit.Abstractions: Abstractions shared by the core library and test adapters
  • FlUnit.Adapters.VSTest: Test adapter for VSTest

• SCClassicalPlanning: Basic but fully functional and documented classical planning implementations for .NET. Somewhat influenced by chapter 10 of "Artificial Intelligence: A Modern Approach" (Russell & Norvig).
• SCFirstOrderLogic: Basic but fully functional and documented first-order logic implementations for .NET. Heavily influenced by chapters 8 and 9 of "Artificial Intelligence: A Modern Approach" (Russell & Norvig).
  • SCFirstOrderLogic: Defines a model for first-order logic sentences (in both raw and CNF forms), and contains logic for sentence creation, manipulation and formatting, as well as data structures for term and clause indexing. Also contains some abstractions for knowledge base types to implement.
  • SCFirstOrderLogic.ExampleDomains: A few simple first-order logic domains declared using the models found in the SCFirstOrderLogic package - for use in tests and demonstrations.
  • SCFirstOrderLogic.Inference.Basic: Some (very) basic inference knowledge base implementations built on the model defined by SCFirstOrderLogic. Not appropriate for use in anything resembling a production scenario, but could be useful for learning and experimentation.
• SCPropositionalLogic: Precursor to SCFirstOrderLogic. Basic but fully functional and documented propositional logic implementations. Based on chapter 7 of "Artificial Intelligence: A Modern Approach" (Russell & Norvig).
• SCGraphTheory: There are obviously a large number of graph theory implementations out there for .NET. None of them really grabbed me though. In particular, I think graph theory is a domain that benefits greatly from a completely separate abstractions package - and it looks like mine's the only one out there that does this. Also perhaps worth noting that one of the most popular (QuickGraph) doesn't seem to have an abstraction for vertices. Which I thought was odd. There's probably a good reason, and I didn't spend very long looking at it, but.. in the end I fancied creating my own, underpinned by a nice, simple, separate abstraction.
  • SCGraphTheory.Abstractions: Abstractions to facilitate graph algorithms that don't depend on a particular graph representation
  • SCGraphTheory.AdjacencyList: Adjacency list implementation of the interfaces in SCGraphTheory.Abstractions
  • SCGraphTheory.Search: Search algorithms that work against any implementation of the interfaces found in SCGraphTheory.Abstractions
• SCSetTrie: A few set trie implementations for .NET. That is, data structures for the storage of sets that facilitate fast retrieval of subsets and supersets of a query term.

• MyOTKE: I got interested in how OpenGL worked at one point, so I made this. A very basic .NET graphics library built on top of the Open Toolkit.
• SharpFontStandard.Runtimes: SharpFontStandard is a managed wrapper for FreeType. For it to work, you obviously need the native libraries at runtime, which it very sensibly doesn't bundle. However, all of the other available packages that exist to provide the native libraries seem to include them as package content, which is entirely the wrong approach, and doesn't work well when the thing that needs it is a library rather than an app. So I made this, which does things the right way - by utilising NuGet's support for runtime dependencies.

I'm occasionally moved to create a gist when I come up with something intreresting that is small enough to express in gist form:

• SqlServerDockerFile: Dockerfile for a SQL server instance built to include a database defined in a given SQL script. Created as part of demo-ing an improved (more isolated) E2E testing approach for work.
• DacPacDockerFile: Dockerfile for a SQL server instance built to include a database defined in a given SQL project. Created as part of demo-ing an improved (more isolated) E2E testing approach for work.
• LinqDecomposer: Uses LINQ expressions to decompose and recompose objects, storing each property in a different backing store.
• ExtensionScripts: Basic example of using MEF and the Roslyn scripting API to create a scriptable extension system.
• Trie: Generic prefix tree, implementing IDictionary<TKey, TValue>.
• BlockingCollectionBatchPipeline: A simple periodic batching pipeline using BlockingCollections