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.

• SCClassicalPlanning: Basic but fully functional and documented classical planning implementations for .NET.
• SCFirstOrderLogic: Basic but fully functional and documented first-order logic implementations for .NET.
  • 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.
• SCGraphTheory: There are myriad graph theory implementations out there for .NET. This one has a dedicated simple abstraction package, making it easy to create/use graph and algorithm implementations independently of one another.
  • SCGraphTheory.Abstractions: Abstractions to facilitate graph algorithms that don't depend on a particular graph representation
  • SCGraphTheory.AdjacencyList: Mutable, in-memory 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

• 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

• 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.
• 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.

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