Projects

This page contains a list of projects I'm either particularly proud of or feel are worth noting. This list will hopefully keep on growing in future!

Cachex is an in-memory caching system for Elixir, built based on the principles of the cache system inside the Java Guava library. It's extremely fast with support for a lot of extra niceties, and as such is becoming a go-to library for caching needs in Elixir.

Eternal

Eternal is a utility used in order to keep an ETS table alive forever in Elixir. ETS tables are associated with a process, and would usually terminate if the process dies. Eternal stops this from happening by using a neat owner/heir system with on-demand GenServers.

Tiny

Tiny is a proof-of-concept JSON parser in Elixir, written with the goal of being minimal and fast while conforming to all JSON standards. As it stands it's comparable to parsers like Poison in terms of speed, but can be considered a good alternative for escript bundles and other embedded builds.

Vessel

Vessel is a MapReduce framework for Elixir, with support for Hadoop Streaming. Rather than dealing with Hadoop protocols directly, Vessel masks them via a straightforward API. Vessel also includes tools to setup Hadoop projects easily, as well as Mix tasks to make compiling your artifacts painless.

Erlang Projects

Global Flags

Global Flags is a library written in Erlang designed to provide an easy way to initialize global flags, without having to be linked to a main application tree. It's aimed at use cases where it's considered expensive to jump to another process, and it's wasteful to have an ETS table.

Sleeplocks

Sleeplocks is a very simple locking library written in Erlang for both Erlang and Elixir. Similar in concept to spinlocking in other language, Sleeplocks uses messaging and other foundational OTP principles to provide locking mechanisms across processes with minimal overhead.

Rust Projects

Bytelines

Bytelines is a Rust library which provides an easy way to read input lines as byte slices for higher efficiency. It's very similar to the tools found in the standard library, but works much more efficiently in situations you don't care about Unicode support in strings.

Detox

Detox is a very small CLI tool used to clean up development directories to save disk space. The main aim is to reduce the amount of space in project directories, such as removing build directories, dependency directories, compressing version control trees, etc.

Efflux

Efflux is a tiny MapReduce framework for Rust, with support for Hadoop Streaming. In order to make it easier to work with Hadoop, Efflux hides the complexity of the Hadoop Streaming protocol behind simple traits. It also ships with templates and project generators for convenience.

Jen

Jen is a data generation utility and CLI written in Rust. Primarily for test datasets or mocking, Jen allows for generation of large amounts of data from an input template, making it easy to produce a solid amount of data for a test suite or integration script quickly and efficiently.

Limber

Limber is a command line tool written in Rust, providing import/export functionality from Elasticsearch clusters. With a focus on efficiency, Limber allows for piping data from one cluster to another quickly, as well as supporting queries for subsets of data and transfers between indices.

Retainer

Retainer is a small caching library in Rust with asynchronous bindings, with support for key expirations based on time. Cache operations have extremely minimal overhead due to the expiration loop being based on a sampling expiration policy, thus allowing for high throughput without contention.

Runiq

Runiq is a small command line utility which offers an efficient way (in both time and space) to filter duplicate entries from textual input. Depending on the use case Runiq offers filters optimized for both speed and memory, allowing developers to choose the tradeoffs to best fit their needs.

Usher

Usher is a small library which provides an easy way to construct parameterized routing trees in Rust. Matching and parameterization rules are defined by the developer using a simple set of traits, allowing for customization in the routing algorithm itself and providing utility in many contexts.