Primary research interest: managing human civilisation under conditions of declining basic resource inputs with a particular emphasis on the moral, social and economic consequences therein (see publications list overleaf).
Teaching experience: significant hours of paid higher education teaching experience (consistently scoring in top quintile in anonymous student feedback).
I am a SCHOLAR AND EDUCATOR with an inter-disciplinary knowledge spanning multiple numerate and non-numerate subjects, in many of which I possess a formal academic qualification. My primary academic research interest is in managing human civilisation under conditions of declining basic resource inputs with a particular emphasis on the moral, social and economic consequences therein.
I have experience in teaching at many diverse levels of academic difficulty, student ability and class size, having approximately two hundred hours of paid higher education teaching experience. I have lectured informally at student societies and gatherings of enthusiasts as well as providing higher education private tuition for students including those with learning difficulties. One of my many experiences involved teaching Economics at degree level at the National University of Ireland (NUI), Cork. As part of this employment, I designed the curriculum and assessment rubrics, and I achieved an excellent average 87.2% class attendance, an 82.8% Interestingness and an 81.2% Clearness rating in the weekly feedback. Another experience involved teaching Business to French undergraduates where I deployed an experimental critical thinking skills curriculum based on Springer and Borthick's 2004 paper, with great success. I have approximately sixty hours of postgraduate tutoring employment in e-Business at NUI Cork, and I have a deep understanding of other cultures through living and working in the countries of Britain, Spain, Ireland and Canada, and in the languages of English (native speaker) and Spanish in which I am conversationally fluent.
std::status_code and std::error
standard error objects.std::filesystem::path_view
was approved by LEWG for entry into C++ 23. std::status_code
and std::error is making good progress at
LEWG, and is hoped to become the new standard error object for
C++. move = bitcopies
has survived EWG-I, and would markedly improve the codegen
of a large class of move-only types (including most STL
containers). std::file_handle and
std::mapped_file_handle continue to
make good progress at LEWG-I, and would bring both very high
performance and concurrency safe file i/o to standard C++, as
well as providing a solid foundation for replacing iostreams
with a more modern alternative. errno-setting
functions such as the C math functions, including providing
seamless interoperation between C code and any future C++ with
lightweight exceptions (see P0709 Zero overhead deterministic exceptions.
P0709 currently awaits a reference compiler implementation,
expected to be funded by Microsoft.std::status_code and std::error
standard error objects.I am a year 2000 graduate of Software Engineering at the University of Hull, England, with extensive experience of working prior to and during my degree, and where my final project was an Object Orientated Hardware Abstraction Layer with a port of the uC/OS II real time operating system. I am also a year 2008 Joint Honours Masters graduate in Economics & Management at the University of St. Andrews, Scotland, where my Masters dissertation topic was on Modelling the Costs of Climate Change and its Costs of Mitigation. In 2009 I graduated with a further Masters in Business Information Systems from NUI University College Cork, Ireland, with my team winning the prestigious 2009 Student Enterprise Awards held annually by Enterprise Ireland, the Irish Government organisation for entrepreneurship, for our Web 2.0 FIXatdl Financial Algorithmic Trading Definition Language Editor. In March 2013 I graduated with a PGCert in Educational and Social Research from the University of London, and in June 2013 I obtained a Certificate in Introduction to Complexity with the Santa Fe Institute. I completed in 2017 a Higher Certificate in Pure Mathematics with the Open University, having taken it part-time by distance over a five year period.
Led out the design and implementation of the custom database part of MayStreet’s replacement for the SEC’s MIDAS platform, which captures all trades in the US including futures and options, and provides live and historical querying of that data to regulatory authorities. This was a challenging project, requiring extreme attention to detail and correctness in order to handle the volumes of data involved, whilst keeping latencies within tens of milliseconds no matter market volatility, and very high uptime and redundancy. Some features:
Literature review of the WG21 papers relating to deterministically handling failure, and using libraries such as Outcome to implement the same.
Helped the Public Key Infrastructure group modernise their twenty-five year old C++ codebase of approx. two million lines of code. Contributions:
Literature review of the several WG21 papers relating to std::expected<T, E>
This was a 100% remote working contract with an onsite visit.
Performed one month of feasibility testing on QuantHouse's main ultra low latency market data supply product FeedOS, producing a report on their future options for reducing latency and increasing density of clients served.
Are you using enums to return error states from functions (or even an int or bool!)? Do you find writing exception safe C++ a poor return on coding investment, and end up avoiding using most of the STL entirely because it could throw exceptions in all sorts of unhelpful places? Have you ever wondered what on earth the C++ 11’s system_error header is actually useful for?
One might think that after thirty years C++ would have decided upon a canonical way of handling errors, but it is very clear the jury remains out with heavy fragmentation in the C++ user base as to how best to handle errors. The new systems programming languages Rust and Swift have chosen a canonical error handling system based on immediate stack unwinding returns of integer error codes in a monadic wrapper e.g. Rust’s ResultT and OptionT. Efforts are underway to standardise something similar for C++ with optional T and soon WG21 LEWG’s expected T, E which recently lost its monadic operations as it gets pared ever further down to its essentials for standardisation.
This talk reviews these four standardised error handling techniques in C++, and how well the three major compilers and library implementations implement these techniques into overhead. I will also be introducing for the first time my own solution to this problem called outcomes (implemented by a proposed Boost.Outcome library) which implement a very impure and dirty - but very lightweight on compile and runtime overhead – simple “mongrel monad” outcome T, result T and option T transport factory specifically targeted at extending C++ 11’s std::exception_ptr and std::error_code in a more convenient to use form, thus providing a unified lossless error handling system for C++. I am hoping these will eventually form part of SG14 (games/low latency)’s recommendations for maximum performance C++ as a lighter weight and more convenient to use for error handling alternative to the LEWG expected T, E.
This is the third and likely final part of a surprisingly popular "from first principles" series of beginner's workshops based on developing the v2 post-peer-review rewrite of proposed Boost.AFIO, a C++ library wrapping the advanced features of the filesystem intended for eventual ISO C++ standardisation. If you're the kind of library developer who likes building unusual low level concurrent algorithms using the very latest C++ 14-17 (proposed) features and testing them for time and space complexities, this is definitely your kind of talk.
At CppCon 2015 we studied the concurrency fundamentals of the filing system, and how it can have the acquire/release semantics of memory atomics but also differs in many ways from memory. At ACCU 2016, using those fundamentals we built from first principles a novel distributed mutual exclusion implementation boost::afio::algorithm::atomic_append which doesn't suffer from the "scalability holes" found in the OS kernel provided facilities boost::afio::algorithm::byte_ranges and boost::afio::algorithm::lock_files. At this third workshop we shall continue the "from first principles" theme by building a fourth and probably last distributed mutual exclusion algorithm for the AFIO algorithms library boost::afio::algorithm, with this one making use of shared memory maps for superior performance when only a single machine is doing the locking.
Is it possible to portably detect the arrival of a networked drive user (SMB, NFS) and safely disable using shared memory maps such that we can automatically race free downgrade our implementation to a networked drive compatible technique?
It turns out that the answer is yes. It has superb performance and scalability, but also comes with many interesting preconditions, tradeoffs and caveats, the most important being that this is an anti-social mutual exclusion algorithm.
Developing from the surprisingly popular CppCon 2015 tutorial “Racing the filesystem” (https://www.youtube.com/watch?v=uhRWM...) on the concurrency fundamentals of the file system, this workshop takes the audience from the fundamental first principles of the file system through to a working and high performance distributed mutual exclusion implementation exclusively using atomic file append messaging based on a modified Maekawa-Suzuki-Kasami distributed voting and mutual consensus algorithm.
Along the way the portable asynchronous file system model supplied by proposed Boost.AFIO will be explained and how such a standardised programming model makes implementing write-once run-anywhere file system algorithms much more tractable. Empirical benchmarks will be shown comparing the scalability of our algorithm to other forms of file system based mutual exclusion such as lock files and byte range locking across Microsoft Windows (NTFS and ReFS), Linux (ext4) and FreeBSD (ZFS). One of the major advantages of our algorithm is that it works perfectly over SMB networked file systems, including mixed POSIX and Microsoft Windows endpoints, and it will be explained how this is not always the case with other mutual exclusion techniques.
With a live demonstration of the working algorithm, the likely audience for this workshop would be similar to that for lock free programming using memory atomics, however the file system exposes a much richer suite of fundamental primitive operations – and unexpected surprises!
This was a 100% remote working contract with a 100% remote working team each member distributed from the US to Continental Europe.
The team I was contracted to was one of many teams working on DTS's (now Tessera) binaural 3D spatialisation technology which provides superior quality rendering at very low CPU cost on the platforms Windows 7 to 10, XBox One, OS X, Android, Linux, and other platforms. It was optimised for the x86, x64, ARM v7a and AArch64 targets via extensive SIMD and micro cache tuning. During this contract, I helped to very substantially refactor the implementation to bring it from an R&D/experimental quality level into state of the art production quality C++ 14/17 with the very latest in C++ best practice.
Almost every programmer knows about and fears race conditions on memory where one strand of execution may concurrently update data in use by another strand of execution, leading to an inconsistent and usually dangerous inconsistent read of program state. Almost every programmer therefore is aware of mutexes, memory ordering, semaphores and the other techniques used to serialise access to memory.
Interestingly, most programmers are but vaguely aware of potential race conditions on the filing system, and as a result write code which assumes that the filing system does not suddenly change out from underneath you when you are working on it. This assumption of a static filing system introduces many potential security bugs never mind ways of crashing your program, and of course creating data loss and corruption.
This workshop will cover some of the ways in which filing system races can confound, and what portable idioms and patterns you should employ to prevent misoperation, even across networked Samba shares. Finally, an introduction of the proposed Boost library AFIO will be made which can help application developers writing filing system race free code portably.
One of the largest single chunks of income for many open source projects is the Google Summer of Code program which pays students to work under mentors to achieve a predeclared set of work items during the annual university summer recess. Mentors receive no compensation, and the main responsibilities of this team management position are as follows:
The first project, proposed Boost.AFIO, is a linear scalable, batch, chainable, asynchronous closure execution engine extending Boost.ASIO and Boost.Thread specialised as a portable asynchronous file i/o implementation library with the student, Paul Kirth, porting an existing pure C++ 11 codebase written and designed by me to Boost and the last three generations of the compilers GCC 4.6, 4.7 and 4.8, Microsoft Visual Studio 2010, 2012 and 2013, and clang/LLVM 3.1, 3.2 and 3.3 on the operating systems Linux, FreeBSD 10 and Microsoft Windows. Proposed Boost.AFIO is an alternative solution to Google's WG21 N3731 (Executors and schedulers v2) proposal, or indeed Microsoft's WG21 N3721 (Improvements to std::future<T> and Related APIs), and it is hoped that AFIO will be the pattern chosen instead for ISO standardisation.
Despite being less than 1000 active LOC, the effort involved in readying this library for peer review has been substantial, and included the configuration of our own custom Jenkins CI running a series of snapshotting VMs and a very extensive automated unit and functional test suite, which runs inside my own personal cloud compute mash up platform based on the Proxmox VE virtualisation solution with three nodes in France, Quebec and in my own home. AFIO now exceeds 20,000 lines of text, most of which is extensive testing and documentation. You may find the official Boost documentation on proposed Boost.AFIO of interest.
The second project, Boost.Trie, implements a STL trie (prefix tree) container for C++. I was selected as one of three mentors for this project due to my domain experience with the popular nedtries open source bitwise tries algorithm library.