1. Tooling applied per-commit, nightly and weekly by the Jenkins continuous integration service. Amongst the many tools applied were automatic style enforcement via a mixture of clang-format and python tooling, linting via clang-tidy on both POSIX and Windows, a full sweep of address, memory, thread, undefined behaviour sanitisers, weekly runs of Dr. Memory for symbolic memory debugging, performance regression testing, line and edge unit test coverage monitoring.
2. I almost entirely rearchitected and reimplemented the build to use state of the art cmake 3 design patterns and single header build enabling a very large reduction in build system maintenance overheads for the team given all the supported platforms. I utilised a "build driver" functional cmake design allowing the team's product to integrate well with multiple externally imposed build systems, thus making all parts build within the wider organisation happy.
3. I implemented multiple low latency and worst execution time techniques, such as enforcing fast-math, disabling C++ exceptions and resurrecting a performance regression test suite. One particular low latency feature item I designed and wrote was an extremely low latency audio scheduler for Windows 7 which is used by the product's Unreal Engine integration to implement spatialised audio for all UE4 games using the native audio system.
4. Most of the Android and ARM (32 and 64) port was done by me with almost all the groundwork done for an iOS port. To port the optimised SIMD routines from AVX/SSE2 intrinsics to ARM, I made use of the excellent Intel SPMD compiler based on LLVM to rewrite the SIMD routines into the ISPC language, and had Python use the ISPC compiler to generate optimised SIMD assembler for Intel x86 and x64, and ARM with NEON2. This allowed very easy tuning for very specific hardware targets simply by changing the ISPC compiler's setting.

1. Improve stability of RUDP and Routing layers, specifically: (a) Systematically investigate the causes of reliability problems in the RUDP and Routing parts of the Maidsafe software platform. (b) Effect changes to the implementation to mitigate such reliability problems. Investigate the problem of UDP packet congestion control, and to substantially improve on the present implementation.
2. To deliver a replacement RUDP implementation semantically compatible with the existing RUDP implementation, but without most of the power consumption, scalability, thread safety and UDP congestion control issues of the present implementation. (a) The replacement RUDP implementation shall aim to meet the Boost C++ Library admission guidelines described at http://www.boost.org/development/requirements.html, except where the proper practice of C++ 11/14 diverges. (b) The design of the replacement RUDP implementation shall take account of the feedback from the extensive stakeholder survey which was performed at the end of Agreement no 1. Stakeholders surveyed were MaidSafe staff, Boost members currently contracted by MaidSafe, the Boost community and the Boost.ASIO community. Records have been kept of all feedback and shall be reviewed again prior to commencement of the replacement implementation. To advise on the technical capabilities of potential new staff or contractors being interviewed. To advise on matters of Business, Management, Information Systems, Economics and Complexity Science and Education, or in any other expert topics in which ned Productions Limited staff hold formal qualifications, and are therefore in a position to advise from authority.
3. To consult and assist on a replacement implementation of the MaidSafe platform written in the Rust programming language. To consult and assist on any systems programming matters which may arise during the contract, which may or may not include the interaction between platform dependencies written in other programming languages such as C or C++. To consult and assist with improved unit testing of the software, specifically improved automation of distributed machine unit testing e.g. a single functional test being performed over a dozen machines each of which is networked behind a NAT being controlled by some unit test master controller. To advise on the technical capabilities of potential new staff or contractors being interviewed. To advise on matters of Business, Management, Information Systems, Economics and Complexity Science and Education, or in any other expert topics in which ned Productions Limited staff hold formal qualifications, and are therefore in a position to advise from authority.

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:

• To petition and cajole some of the top minds in C++ to mentor a student for three months, as well as to write up descriptions of a set of suitable student work items from which students may pick.
• To review the technical content of proposed student work items for suitability, particularly to encourage mentors to break up work items into smaller, more tightly defined chunks and to add additional clarifying documentation where necessary.
• To encourage and remind the Boost community to do peer review on student submissions as part of the candidate ranking process.
• To lead out matching up potential mentors with potential students where a project proposal lacks a predefined mentor.
• To assist answering questions about the GSoC process from both students and mentors.
• To be the primary liaison between Google and the Boost community, including the Boost steering committee, delegating work to others where appropriate.
• To arbitrate between students and mentors when disagreements occur, and to review student work independently as part of reporting to the Boost steering committee on progress and goals achieved.

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.

1. Pursue leading-edge research that significantly advances complexity science and its practical application to humanity’s problems;
2. Create a vigorous university-wide research community in the field of complexity and innovation studies;
3. Link this community through research projects and exchange of knowledge with the global complexity-science community; and,
4. Establish the University of Waterloo as a world leader in efforts to use complex-systems ideas to promote innovation to solve multi-scale, systems-level global problems.

1. The component objectivisation of the C++ application binary interface using the advanced capabilities of the clang compiler to extend the C++-1y Modules proposal (WG21 N3347) with an additional layer of information abstraction in order to very substantially reduce the coupling between software components, and therefore inhibit constant breakages of source code trunk due to it being a never ending moving target. It is well known that Microsoft's COM, a much simpler implementation though similar in spirit, is regarded by Microsoft as one of their greatest internal productivity enhancement technologies ever developed. This generated a 12,000 line working prototype which I proposed via an internal 10,000 word white paper for ISO C++ standardisation, perhaps initially as part of the Boost C++ libraries.
2. The employment of the open source memory analysis tool valgrind as part of platform and application performance and hardware prototype simulation, and automated testing and regression. I added a significant improvement to the callgrind tool, adding the ability to estimate CPU time from the call tree using empirical timings which came in within 20% of reality on the Qualcomm Snapdragon S4 Pro CPU (note that this CPU has non-linear execution dynamics) and 10% of reality on Intel x86/x64 CPUs.
3. The generation, analysis and manipulation of large (hundreds of thousands of vertices) graphs of live semantic information about the hardware and software making up BB10, most specifically the call tree for a Cascades EmailCard process launch output by my improvements to the callgrind tool, and for which I wrote a custom callgrind to time weighted GraphML directed graph format parser using Boost.Spirit. Visualising usefully the incredible complexity of modern C++ call tree graphs was a good workout of my Econometrics training.
4. I led out, implemented and finished a port of the clang/LLVM compiler stack plus compiler-rt runtime to QNX and BB10. Watching LLVM generated from some of the five million lines of BB10 C++ system libraries I had ported to clang be JITed into ARM on device was quite neat. My need for a clang/LLVM port was an idea for a clang AST based C++ library API review automation tool which would have replaced a majority of the manual human effort expended on internal API review.
5. I initiated and participated in a series of summer meetings between Gary Klassen and Sean Simmons with the University of Waterloo with a view to creating much closer relations between BlackBerry and their technology startup spin out programme. This was facilitated by me being an Affiliate Researcher with the UW Research Institute for Complexity and Innovation (WICI).
6. A side project of mine was a regular series of internal white papers using Econometrics to empirically compare BB10 major releases with the competing mobile device platforms Android 4.2 and Microsoft Windows Phone 8, along with desktop operating systems for good measure. Some of the statistical approaches I took were information entropy analysis, Zipf's Law identification of statistical outliers, and Lempel-Ziv-Markov chain analysis of duplicated assets in private memory. Some of the graphs from those papers can partially be seen here.

• Implemented using the GIT source control system to send compressed deltas of changed data over a Virtual Private Network (VPN) via 3G to and from a Linux mini-server. The core program was written in Python using the dulwich python implementation of GIT. A convenience GUI written in C# and .NET 3.5/2.0 operated OpenVPN and the python core program.

• The project was aimed especially at the transnational education market due to three particular features:
  1. The generation of a timeline of activities performed by the student when writing the academic work output. Activities recorded included which internet searches were performed, what results were returned, which links were clicked in these results, which parts of each web page or PDF document were viewed and what interactions were made via social networking with other people. This feature is especially useful for proving that plagiarism did not occur, as well as automating the generation of the bibliography of the academic work output, as well as for ethnographic study of how people go about socially constructing any form of text.
  2. Latent Semantic Analysis (LSA) and Latent Dirichlet Allocation (LDA) were employed to analyse the topics which traverse throughout the student's activities and their academic work output. This allowed a viewer e.g. the assessor to generate a "blame" history for any sentence or paragraph in the work output i.e. the tapestry of those parts of all the materials read by the student during the genesis of the academic work output.
  3. All the data and metadata recorded by the software was stored on the cloud (Google Cloud Storage/Amazon S3) where a series of useful operations could be performed upon it such as being able to suggest, in real-time, additional articles for a student to study during the writing of an essay on the basis of what other students studied during the writing of similar essays.
• Some unusual and interesting technologies were employed during the development of this project. The Microsoft Office plugin was written in C# utilising .NET 3.5/2.0. The web browser extensions (for Internet Explorer, Mozilla Firefox, Opera and Google Chrome) were written in Javascript and jQuery using the Crossrider cross-browser extension framework. Both the web browser extensions and the Microsoft Office plugin used JSON-RPC v2 to communicate with a multithreaded client-local server written in Python which stored all the data as reduced OpenXML or sanitised XHTML in a NoSQL XML database called BaseX. The Latent Semantic Analysis (LSA) and Latent Dirichlet Allocation (LDA) was performed using the Gensim python library. Access to Google Cloud Storage and Amazon S3 was performed using the Boto python library. It was intended to use Google App Engine to perform the cloud execution portion of the project, but unfortunately the project had to be abandoned before implementation of this portion could be begun.

• Topics taught were: (i) International Business (ii) International Law (iii) Advertising, Marketing, Banking, Finance (iv) The European Union. Each of these was delivered via a critical approach making particular use of annotated contemporary articles from the business press and audio-visual techniques to overcome the lack of native English barrier to comprehension.
• A particularly interesting component of the curriculum delivered during this course was a component of critical thinking Business skills based on Springer, C.W. and Borthick, A.F., (2004), 'Business Simulation to Stage Critical Thinking in Introductory Accounting: Rationale, Design, and Implementation', Issues in Accounting Education, vol. 19 no. 3, pp. 277-303. During action research performed during the teaching of the course, I determined that the students would prefer a more practical business task solving approach to their group work activities. On searching the literature, I found the above paper which presents a seven-stage assignment plan from which I derived a very similar plan.

• Started the process by deploying a custom website where people could collaborate on the development of a standard proposal for C1X. This phase ended in October 2010.
• From this proposal developed the N1527 document along with two C99 implementations which went to the March 2011 London C1X committee meeting.
• As a result of the deliberations of this meeting, substantial changes are currently being made and a new change document being written.

• Especially given that I had no prior academic experience in this field, nor even much outside the social sciences, the paper could not have possibly been written without the most helpful advice, detailed comments and patience from Doug Lea of the State University of New York at Oswego, USA; David Dice from Oracle Inc. of California, USA; and Peter Buhr of the University of Waterloo, Canada.

• As part of the contract tendering process, a quick technology demonstration was written to determine the potential performance improvements. It was discovered that remapping memory pages via the manipulation of the processor's memory management unit is around twenty times faster than copying 4Kb of memory (on Intel Core 2) and around sixty five times faster than copying 16Kb of memory. This meant that large arrays of items could be extended several orders of magnitude faster than is traditionally the case. These results were sufficient to convince the customer to initiate the contract.
• After implementation we found a further inadvertent cause of even higher performance gains: the avoidance of having to clear newly allocated memory. This allowed nedmalloc to run 20-25x faster when manipulating allocations averaging 1Mb with exponentially larger gains for larger allocations.
• We later discovered an academic paper partially proposing a similar idea entitled EVector: An efficient vector implementation - Using virtual memory for improving memory by Kimpe, Vandewalle & Poedts (2006). Our implementation is very different to theirs however, and so superior are the performance benefits that an academic paper detailing the new approach is in the process of becoming published.

• Determined that the source of their problems was that nedmalloc was not being reliably called by their Qt-based application (a violation of the ODR) which was causing segmentation faults. Many solutions were analysed, and eventually a brute force approach of adding a binary patcher was adopted which had the major long term cost advantage of not requiring a custom build of Qt. This binary patcher replaced all usage of the system allocator with usage of nedmalloc by rewriting the appropriate parts of the PE format binaries on Windows.
• One particular problem was handling system allocated blocks efficiently as the logic for checking for such blocks is highly branch predictor unfriendly. An initial 13% loss in performance on x86 was reduced to nil through considerable hand tuning and analysis of assembler.
• Even with the slight performance loss on x64, nedmalloc still remains the fastest free portable memory allocator in the world, a title it has held since 2006. It is now however much more flexible and useful than before especially with respect to debugging facilities.

• The RoIP server was a custom Linux installation running the Asterisk VoIP server software. The radio interface app_rpt was used to communicate with the radio via a USB FOB (basically a USB connected sound card).
• Remote PCs then used the IAXRPT Windows client to perform an IAX protocol connection with the RoIP server. To the end user, after connection one hears the radio chatter and presses the left Ctrl button to press PTT and transmit.

• Designed the syllabus of the course to dovetail in with the other modules taught in the Degree. Coursework consisted of five readings from five topical books with a series of questions which were marked each week.
• Topics covered include non-linear chaotic dynamic systems, information asymmetries, energy return on investment (EROI), volatility and periodicity in economic growth, the disequilibrium structures within demand and supply, the sources of the Celtic Tiger, the Gaussian distribution and the central limit theorem, correlation and convertibility of energy, food and water.

• Upgraded the OpenGL runtime to use FBOs instead of PBuffers and updated the texture transfer to use PBO-based asynchronous DMA transfers, thus significantly increasing speed and adding full compatibility with Linux and Mac OS X.
• Added a GLSL output runtime target, thus matching the OpenGL capabilities with the DirectX runtime.
• Added per-thread operation to all runtimes, thus allowing multiple GPU’s to be operated in parallel simultaneously.
• Upgraded the CPU debug runtime to use SSE intrinsics on x86 and x64 processors and OpenMP to use multiple processors. Performance was increased some forty times.

• The heterodox Economist Paul Ormerod (author of Butterfly Economics).
• Founder of the Schumacher College and Editor of Resurgence Magazine Satish Kumar.
• The world’s leading authority on Accounting theory Professor Rob Gray.
• One of the world’s most famous Historiographers Professor Michael Bentley.
• One of the world’s leading environmentalists, Sir Crispin Tickell GCMG KCVO. This event was chaired by the then St. Andrews Rector, Mr. Simon Pepper OBE (of the World Wildlife Fund).

• Identical functionality on Microsoft Windows, Unix & Apple MacOS X.
• An extremely flexible thread-safe & exception-safe 64 bit addressing i/o structure.
  • Classes which provide file i/o, named pipe i/o, socket i/o (IPv4 & IPv6), inter-thread i/o, shared memory & memory mapped file i/o, strong file encryption and SSL/TLS secure connectivity via the OpenSSL library.
• Superior generic and robustness compile-time programming tools e.g. typelists, traits, policies, rollbacks etc.
• A full set of multithreading primitives, some written in x86 assembler for speed plus dynamic thread pools.
• Automatic human-language translation and locale specialisation facilities via Google Translate.
• A full set of bindings for python using the Boost.Python library.
• Automatic munging in by a python script of extra run-time support code providing nested C++ exceptions plus automatic extraction of error codes and user-visible text for translation.
• Full integration with host OS security facilities, including Win32 ACL based security and POSIX user & group ID.
• Arbitrary freestores based on nedmalloc (previously ptmalloc2) giving >6000% speed improvement in dynamic memory allocation over Win32.
• Easily extensible & extremely efficient generic Inter Process Communication framework with asynchronous i/o and optional zlib compression. Can transport arbitrary C++ objects across any i/o device listed above.
• Full SQL database support with native SQLite3 and via-IPC drivers.
• Substantial OpenGL-based 3D and 2D graphing facilities.
• Patched and reworked FOX to provide per-thread event loops allowing multiple window trees to be run concurrently.

• To make software self-organising and self-optimising based upon system (ecosystem) and complexity theory (c.f. Bateson, Heisenburg, Prigogine) whereby tools magnify the effectiveness of effort.
• To conceptualise all programming and user operation in simple cognitive elements, thus greatly improving intuitiveness of operation and much increased productivity.
• To integrate all software components across multiple systems such that they appear and act as one.
• To be fully secure at all levels whilst remaining compatible with the host OS – this is a full capability based system.

• The project’s goal was to be a bench-portable test bench control and component management software plus bench-customisations for the (i) M-3011 Hydraulic Test Bench Bench (contracted by EADS Deutschland) and (ii) B-1057 Fuel Component Test Bench (contracted by British Aerospace Systems) for the EuroFighter project.
• Innovative features included:
  • A self-adapting help system which taught the user as they used the bench. This was written in HTML with custom embedded ActiveX controls (MS HTMLHelp).
  • A graphical virtual instrument showing fuel flows, valve positions etc. which were manipulable using the mouse. This was implemented using a custom designed scripting language to specify possible fuel flows and possible valve states.
  • A searchable library of all engineering specifications in multiple formats including SGML, PDF and MS Word.
  • A completely customisable UUT test report generator (using Crystal Reports) which each air force could tailor individually.
  • The application could run on two computers connected by TCP/IP at the same time controlling the same bench.
• Due to the high performance & safety requirements of testing EuroFighter aircraft components, the code was written from the ground-up to be efficient and with my own design of structured exception handling. The Continuous Built-In Test (CBIT) was so accurate it detected hardware problems no human could and required specialised equipment to solve.
• Performance analysis at the end of project using tools designed by myself showed 5000 i/o's per second sustained (well above specification).
• The core was written in ANSI C but had ActiveX extensions support e.g. a stopwatch & timer (VisualBasic), report generator (Crystal Reports, MFC & Visual C++) and a voltmeter (LabView).
• The database for the component (UUT) management was based in MySQL manually linked against a disc based store of i/o transcripts and test reports. Specialised support was present to suspend MySQL & compress its data store into a single file which then was burned regularly to a backup CD.
• Other responsibilities I assumed there included liasing extensively with EADS, BAE and directly with the militaries of the four EuroFighter participating nations.
• While I implemented much of the core code myself (there was only myself for the first six months), I also mentored & led two other programmers during my time there.

• Replaced the real-time operating system (RTOS) in their GPS (Global Positioning System) library for their embedded ARM device with a licensed third-party RTOS called SuperTask! (made by US Software).
• Implemented and integrated many new features including Flash ROM reprogramming, serial port driver, LCD panel display driver, power saving and Infra-Red communications.
• Merged ARM's Demon debugger into the new operating system, allowing debugging without a JTAG and ICE (In-Circuit Emulator) based debugger.

• Wrote a driver for ARM’s Angel debugger to drive a tertiary serial port on the Cirrus Logic CLPS-7111 board. Due to hardware difficulties, successfully used a logic analyser to implement the code.
• Wrote a modular EEPROM programmer in C++ for Win32 allowing test ROM images to be easily flashed into test boards.
• Overhauled and redesigned DEC's StrongARM uHAL for generic Arm's and ported the new uHAL to the Arm test motherboard, the PID7T. Also ported the redesigned uHAL to the Cirrus Logic CL-7111 board.

• The project’s goal was to permit Unix applications to query Windows-only databases on one or more Windows machines over a TCP/IP based network.
• Implemented a number of engines for this system using third party search engines (native to Windows) such as the Royal Mail PAF (Post office Address File) engine and a Read code v3 (used in the English National Health Service) engine.

• Helped upgrade the integrated package PipeDream from v4.13 to v4.5 which incorporated StrongARM compatibility and a number of enhancements.
• Manned the technical support desk dealing with both telephone and written queries.
• Designed an advertisement for publication in Acorn User.