Software development

Applications, services, and the scripts that hold a process together. The language follows whatever already runs where the code has to live, which in practice has meant Python more often than not, with a fair amount of PHP, Java, JavaScript and shell alongside it.

01

Languages and why

Taken from work that shipped, not from a preference list.

LanguageWhere it comes upReach
Shell and bashProvisioning, backups, install scripts, anything that has to run on a machine before a language runtime exists on itMost used
PythonData systems, services, trading engines, vision and automation toolingMost used
PHPExisting web applications, mostly extending rather than replacingCommon
JavaScript and Node.jsWeb front ends, integration scripts, and services that talk to browser clientsCommon
JavaServices where the surrounding infrastructure is Java, usually on AzureOccasional
CKernel and device work, embedded firmware, performance critical pathsOccasional
02

What I build

Data systems

Collection, processing, and storage, with the query patterns worked out before the schema is fixed. Usually PostgreSQL or MongoDB depending on how the data is shaped rather than on preference.

Trading and low latency

Order handling and data paths built to a latency requirement. Readability is the first thing sacrificed because the client asked for latency, and that trade should be stated rather than discovered later.

Web and API services

Services and endpoints built for whoever has to maintain them, which usually means sensible structure, a health check, and documentation that matches the code rather than describing an earlier version of it.

Existing codebases

Work on applications nobody would choose to write today. Modernising or extending usually beats rewriting, and I will say which of the two the job needs before either one starts.

Reporting and dashboards

Dashboards over data that already exists, built so a client can keep maintaining them. Looker Studio and similar, where the client needs to explore the data rather than look at a fixed chart.

Integration scripts

The connective tissue between two systems that were never designed to talk. Usually unglamorous, usually the thing holding a process together, and usually undocumented until it breaks.

03

Work done in this area

Low latency trading engine
An order handling engine built to a stated latency requirement, where readability had to give way to the target. The algorithmic review came before the performance work.
Stack
Python, Linux, algorithms, Metatrader
Stock data system
Collection and processing of market data into a queryable store, built for reliability over reporting. Described by the client as excellent problem solving with minimal disruption.
Stack
Python, MongoDB, Node.js, PostgreSQL, Redis
Peppol architecture and implementation
Architecture, API integrations, and the build, delivered against agreed milestones on time. Called a pleasure to work on.
Stack
API integration, system architecture, cloud computing
Cross platform game
A mobile and web game delivered across platforms from one codebase, packaged for phone, tablet and browser.
Stack
PHP, JavaScript, Node.js, PhoneGap
User management application
A small application delivered inside the agreed time, deployed on Azure with container orchestration around it.
Stack
Java, Azure, Docker, Kubernetes, Terraform
Web application deployment
Deployment and DNS for a dynamic website, plus the small fixes the handover always turns up. Delivered on time and to a higher standard than expected.
Stack
PHP, Node.js, GitHub, DNS, web hosting
Looker Studio dashboard
A reporting dashboard built and handed over, with the phases documented so the client could continue it without me.
Stack
PHP, Python, Google App Engine, software architecture
VOD encoding pipeline
A media application built alongside the encoding work it drives, covered on the video and television page.
Stack
PHP, Python, MySQL, FFmpeg, Linux
Media retrieval tooling
A downloader and retrieval tool built to a stated scope and delivered as a quick, clean piece of work.
Stack
Python, Linux
Legacy codebase maintenance
Maintenance of an existing Python codebase for a stock market client, covering the parts that were undocumented and had become load bearing.
Stack
Python, Linux, system administration
04

Questions

Will you rewrite something that already works?

Not without a reason. A rewrite is usually the riskiest thing on the table, because the current version carries a set of fixes nobody wrote down and everybody relies on. I will extend or refactor where that is genuinely the lower risk, and say so when it is not.

What happens to the code after you finish?

You get it, and you can read it. That is the point of writing for the maintainer rather than for the demo. Structure, a health check, and documentation that matches the code are included as part of the work, not sold as an extra.

Do you work with an existing codebase?

Most of the time, and it is often the more useful job. A system that works but that nobody can safely change is the usual reason a team is looking for help. Getting it into a state where another developer can move safely is a reasonable first piece of work.

Why did you not recommend a different language?

Because the choice is driven by where the code has to live and what is already around it. Rewriting an application in a language you like more is a cost with no benefit attached, and I have usually talked clients out of that rather than into it. See Linux and systems for the host side.