James Rowley

I develop Python applications, usually in support of a piece of hardware. This includes everything from driver development at the socket/serial level, to wrapping vendor drives in a Pythonic API, all the way up to desktop GUI development with Qt. Data processing and transformation with NumPy and SciPy is frequently a feature of these applications; for example, decoding RFID communications from time-series data. I strive to write Pythonic code that best applies the principles of Object-Oriented Programming, with the end goal of having everything I develop be ready for future expansion and free of technical debt. I take pride in applying stringent coding standards to my work, with automatic format checking by Black, Flake8, and Flake8's many extensions, often running automatically when checked into Git on a Jenkins CI server. This reduces differences between commits, particularly on projects with multiple developers, making history and pull request review as straightfoward as possible. I additionally am a strong proponent of type annotation in Python; even the smallest, hackiest scripts I write are fully annotated and checked with MyPy. The result is that I catch a large portion of bugs and typos before I ever run my code, accelerating development and helping cut down edge cases.

I have settled on Qt with PySide as my GUI toolkit of choice when working in Python, out of appreciation for its comprehensive feature set, and how many things "just work" while remaining fully customizable. Note that I do not have experience with Qt outside of Python, although I am conceptually familiar with C++. One example of an application I developed with Qt and Python is a "code builder" tool for a motion control application. This consists of a number of "wizards" using QTreeWidget to present a curated version of the global namespace to the user, and let them generate lines of code to update properties or wait for conditions to be true. Generated lines of code appear in a drag-and-drop interface to allow for reordering, as well as displaying the currently running line when executing. This application was developed with Qt 5, Python 3.7 and PySide2, and has full high-DPI support including in multiple-monitor scenarios.

I use NumPy and SciPy for all sorts of data processing in Python, from analyzing oscilloscope captures in real-time, to porting Mathematica/MATLAB applications to Python. The most interesting thing I've done with NumPy/SciPy, as well as the most performance-sensitive, was decoding ISO 14443B (RFID) data from a time-series captured on an inductive coil at about 100Msa/s. I built an object-oriented layer on top of NumPy/SciPy to contain waveform data and do different filtering/resizing operations on it while maintaining the timing of the signal. Developing a decoding algorithm that could run in near real-time required some creativity, as the amount of data being processed ruled out any pure-Python operations. This decoder was then integrated with a USB capture driver I wrote for the oscilloscope for automated operation. Another project I utilized NumPy for was porting an algorithm for processing EEG data from Mathematica to Python, before ultimately porting it to C. The Python port allowed us to understand the little nuances of the Mathematica code (i.e. non-obvious default behaviors in Mathematica) before optimizing the algorithm to run on an embedded device, and ultimately porting it to C. Having this Python port also allowed us to automatically compare the performance of different algorithm variants against each other and against clinical data.

I administrate my company's Jenkins CI server. Its primary function is running automatic code quality checks and unit tests on every commit to our software repositories. We exclusively use the "Multibranch Pipeline" mode, and I have written reusable pipelines for both Python and C projects. I also wrote a Groovy library for building MPLAB X (embedded C) projects from Jenkins, and have written some Groovy/Powershell scripts that automate the release process for our largest projects.

Most of my initial programming experience was in web development, and I briefly worked as a web developer for the University of Arizona. I'll admit that I'm a bit rusty on it by now but I still have some web applications I maintain. Two examples: A PHP 5 based webapp for managing scoring and scheduling data at robotics competitions. This included a fully custom frontend and backend framework for page layout, user management, security, etc. About half the application was basically an interface to editing SQL tables, with some presentation logic for application-specific datatypes. The table editor involved a lot of JavaScript to keep all interactions on one page. The rest of the application was views of that data, e.g. a "big screen" display of the current match, an interface for judges to input scores, a "show control" remote to manage the match clock. I later reused this codebase to track food donations for a food bank. A patient data collection system for a medical study. This is written in Python/Flask and is still in operation. Patients are assigned to control or non-control group, and data is collected on their progression over the course of a year. Clinicians are restricted to viewing/editing data on patients at their particular site, while the study administrator has read access to all. More details about some of these on my website: http://www.jrowley.me/portfolio.html

Embedded systems engineering is my primary responsibility at my day job. I manage (and often execute) the whole development cycle, from requirements capture, to electronics design, to schematic capture, to PCB layout, to firmware development, to assembly/test, and finally to requirements verification. I have extensive experience with Microchip's 8-bit PIC microcontrollers, including PIC18 assembly language. I have also worked quite a bit with the MIPS-based PIC32M series, and even dsPIC and SAMD processors. I also have some experience with FPGA development in Verilog, with Xilinx and Lattice FPGAs. Fun fact: some of the new PIC18's have enough hardware peripherals that you practically have a CPLD built in... I once implemented a 1-wire transceiver on top of the SPI peripheral almost entirely in hardware, inside a PIC18. My experience is broad, covering power analysis and power supply design, microcontroller selection, communication bus selection and protocol design, high-speed signals (e.g. USB), and even precision analog signal capture... maybe don't ask me for help on the analog stuff though! See some more project details on my website: http://www.jrowley.me/projects.html I put this experience at the end because embedded systems development, even if we're only talking about firmware, is intrinsically linked to the hardware. And that's hard to debug remotely. I've spent hours analyzing potential failure modes only to find out the client had plugged the thing in wrong (despite "triple checking" it...). So I am happy to try and help. But keep in mind that I don't know about the parts of your system that I can't see.