Rud Pedersen

3 mos · Self-employed

• CLanguage models can produce clear, confident responses that are wrong. Incorrect claims take different forms — from asserted figures to tool choices and biographical details — so a single generic test cannot verify them all.
• SApplied one verification principle through claim-specific checks: compare every model response with independent evidence. Recomputed asserted figures from source data, measured whether the live assistant interpreted the user's intent and selected the correct tool across repeated runs using the production instructions, and validated biographical claims against candidate data — the source of truth — before rendering.
• REach response type now has a matching verification gate: incorrect figures stop the build, intermittent assistant errors are reported as rates, and unsupported biographical claims are rejected before rendering. The principle is reusable wherever a language model makes a claim.

LLM output verification, independent recomputation of asserted figures, live-model behavioral testing, repeated-run scoring for non-deterministic output, LLM classification scoring harness, prompt evaluation against production instructions, provenance validation against source data, separation of claims with one owner per gate, node:test, Playwright

Related: Created Agentic Health principles to measure and verify changes made by coding agents, Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Automated narrated product-demo video production

Hide details

2 mos · Self-employed

• CA narrated product demo requires camera movement, application state, captions, speech, timing, and encoding to stay synchronized. Recording and retiming all of that by hand made each product change expensive.
• SBuilt a browser-driven pipeline that turns a written story into a finished video by controlling the real application, camera, timeline, captions, generated narration, audio levels, and encoding. Added a browser editor for minor adjustments, generated still frames and timing reports for visual review.
• RDemo videos became reproducible and can easily be regenerated and retimed as the product changed, without recording or editing every sequence by hand.

Playwright-driven application capture, text-to-speech narration and audio mastering, ffmpeg encoding pipeline, browser-based timeline editor, story-as-code definitions, visual QA frames and beat reports

Related: Built checks that catch false claims from language models

Hide details

3 mos · Self-employed

• CBroad requests such as "show me…" or "how has X developed" require the AI assistant to choose a suitable chart and axes. Its small text model could not make those choices consistently or explainably.
• SKept chart and axis selection mechanical and deterministic: code scores column statistics against a written taxonomy of visualization tasks, while the model interprets the user's request. A fixed set of cases with agreed correct answers tests the recommender.
• RChart recommendations became consistent, reproducible, and explainable from the user's intent and based on the data's own statistics. Changes to the selection code can be checked against the same expected cases.

deterministic recommendation from column statistics, visualization-task taxonomy, golden-set regression testing

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Kept large datasets in the browser while the language model worked from compact references

Hide details

5 mos · Self-employed

• CThe product needed user authentication before people could safely save datasets and chart configurations. A database would have added unnecessary complexity, but shared file storage would allow one user to access another's work.
• SAdded registration, login, logout, and password reset with signed session cookies, and protected every saved-work route with authentication middleware. The authenticated user identity is passed to route handlers and used to isolate file storage in a dedicated per-user directory, with path checks preventing access outside that directory. A read-only demo tenant and development bypass preserve a simple workflow.
• RAuthenticated users can save and reload only their own datasets and charts. Per-user file isolation provides the required access boundary while retaining simple file-based persistence instead of introducing a database.

Express authentication middleware, HTTP-only signed session cookies, Scrypt password hashing, Nodemailer-compatible password reset, per-user filesystem namespaces, path traversal guards, fetchWithAuth and fetchWithCredentials conventions, demo tenant sentinel

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend

Hide details

6 mos · Self-employed

• CA language model needed to transform user data without being allowed to run generated code. Every derived value also needed a reproducible history, correct handling of missing data, and a safe way to reverse changes.
• SBuilt eleven validated transformation operations that the model calls with structured parameters. Formula text is separated into known elements, checked against a limited grammar and an approved function list, then calculated row by row without eval() or Function(). Referenced columns are validated before execution, missing values remain missing instead of becoming zero, and every operation is recorded so the result can be inspected, replayed, or undone.
• RUsers can transform data in plain language (calculate a new column 'price-with-tax' as 'price * 1.2'), inspect how each figure was produced, and undo or replay any step. Deterministic operations and regression tests make results reproducible and verifiable, while the model remains useful without receiving code-execution access.

hand-written tokenizer, recursive-descent parser, and AST interpreter, expression evaluation without eval() or Function(), event sourcing with undo and history, null-propagating semantics, TypeScript discriminated unions and compile-time exhaustive coverage, single allowlist of formula functions, column-reference validation

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Kept large datasets in the browser while the language model worked from compact references

Hide details

6 mos · Self-employed

• CThe XR-Data-Explorer as a minimum viable product (MVP) needed to run with secure access, durable data, provider credentials, and useful logs. Deployment also had to be simple and repeatable.
• SScripted a Hetzner deployment on Ubuntu 24.04, with Caddy handling Transport Layer Security (TLS) and routing, PM2 managing the Node.js processes, and settings supplied through environment variables. Separated persistent state and deployment settings from the application code so updates could replace the checkout without losing data, and added authenticated service access and logs.
• RThe MVP now runs as a service for demos and real feedback, with state that survives replacing the application checkout. Deployment follows a repeatable procedure instead of remembered server steps.

Hetzner Cloud, Ubuntu 24.04, Caddy, PM2, Node.js, TLS, cron, Git deploy keys, environment-based configuration

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend

Hide details

6 mos · Self-employed

• CThe AI assistant needed lower latency and token use, but optimization ideas and alternative models could add complexity or weaken reliable tool use. Decisions needed repeatable evidence rather than isolated impressions.
• SStarted by testing token-optimization strategies and establishing an end-to-end LLM benchmark for latency, token use, and tool-call reliability across Chat Completions and Realtime sessions. Later trialled different hosted models through OpenRouter, followed by a smaller set of CPU-only Ollama trials on a Hetzner VPS and a local machine.
• RThe benchmark showed that instruction tuning reduced output tokens without cascading timeouts, while dynamic tool and prompt selection added complexity for negligible savings. The later trials broadened the model comparison, while CPU-only local and Hetzner models remained experimental because they could not sustain dependable tool use and long agent loops.

LLM benchmark harness, OpenAI Chat Completions, OpenAI Realtime, token and latency analysis, instruction tuning, tool-call chain analysis, lower-only ratchet tests for payload budgets, OpenRouter, Ollama, Qwen, Llama, Gemma, Hetzner VPS, SSH tunneling, OpenAI-compatible local endpoints

Hide details

7 mos · Self-employed

• CUser feedback and browser errors needed to become reproducible engineering work without asking people to reconstruct the session, data, chart, and server activity behind them. The workflow needed to begin with human judgment at the task boundary while establishing a safe path toward end-to-end automation.
• SBuilt a human-in-the-loop intake workflow around the AI assistant's feedback command and two complementary skills. The command records feedback with a session trace ID and optional chart and data attachments; feedback-to-tasks correlates relevant session, backend, and Model Context Protocol (MCP) logs and proposes evidence-backed tasks; create-task gives directly reported issues the same problem-first structure, duplicate checks, assessment when applicable, and routing to planning or implementation. A person confirms each task before creation.
• RFeedback and logged errors can enter the same traceable task pipeline with evidence preserved for diagnosis and verification. Human confirmation remains in place, while structured artifacts, API-backed task state, and downstream routing prepare the workflow for future automation from a user report or browser-log error through code changes and verification.

Pino structured logging, configurable LOG_LEVEL and module-specific log levels, VITE_LOG_LEVEL for browser logging, Socket.IO log transport, JSONL session, backend, and MCP logs, trace ID correlation, AIA feedback commands, feedback-to-tasks skill workflow, chart PNG and data-file attachments

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Built a simple file-based task tracker that agents and people both work from

Hide details

5 mos · Self-employed

• CAgents and people needed a simple, readable shared task state that lived beside the code, without an external tracker, network access, or a second source of truth. The workflow also needed customization for agentic coding tags and Agentic Health scoring.
• SStarted with quick repository-local JSON files to keep task data readable, versioned, and easy to customize. After the approach proved valuable, added a small REST API and dashboard with schema validation, workflow states, approval gates, authentication, and links to plans and reviews. Used lock files, temporary files, and atomic writes to protect updates from interruption.
• RAgents and people now work from the same versioned task through planning, implementation, review, and production verification. Each task and the code that completes it travel through repository history together.

TypeScript, Express, REST API, JSON file persistence, atomic writes, schema validation, session cookie and bearer-token auth

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Built a human-in-the-loop, automation-ready workflow from feedback to verified code

Hide details

8 mos · Self-employed

• CThe product supported only one person at a time. Collaboration required people in headsets and browsers to share data, charts, presence, and conversation while handling concurrent changes and bringing late arrivals into the current session.
• SBuilt signed Socket.IO rooms that keep datasets and charts synchronized across extended reality (XR), the web interface, and AI-created charts. Presence, very simple avatars, and spatial WebRTC voice connect participants, while object locks prevent conflicting changes. Content hashes avoid duplicate dataset uploads, and state recovery gives late joiners the room's current analysis.
• RPeople in headsets and desktop browsers can now explore the same datasets and charts together. Late joiners continue from the current room state instead of starting over.

Socket.IO, WebRTC voice chat, Web Audio API spatial audio, Three.js avatars, JWT room tokens, REST room data store, content-hash dataset deduplication, WebXR, ECharts and ECharts-GL

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend

Hide details

1 yr 1 mo · Self-employed

• CCoding agents can produce changes quickly, but with risks of duplicate logic, hidden assumptions, and breaking distant parts of a codebase. Existing quality measures did not show whether an agent could find the right code, understand its contracts, or prove a change was safe.
• SBuilt Agentic Health, a framework and command-line assessor that scores structure, naming and types, discoverability, and verification. Used those scores within a single-source-of-truth workflow: one owner for each concept, contracts in types, small interfaces, code and interface reviews by a fresh agents, and a fixed check order: type checking, linting, unit and end-to-end tests.
• RRefactoring priorities became measurable, and every change followed the same evidence-backed path from task to verification. Faster development with coding agents became safer, and the framework can be applied to any codebase to make it agent-ready.

Node.js CLI tooling, Git churn analysis, static code analysis, SC/SP/DC/VF criteria, JSON output for agent consumption, TypeScript contracts, modular architecture, code review artifacts, architecture guides, Agentic Health criteria, node:test, Playwright, TypeScript type checking, ESLint, fixture validation, unit and e2e harness scripts

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Built checks that catch false claims from language models

Hide details

1 yr 4 mos · Self-employed

• CA VR charting prototype needed data handling, desktop views, collaboration, accounts, and saved work. Its growing JavaScript and TypeScript codebase also had unclear boundaries and scattered tests, which made development with coding agents difficult.
• SBuilt the missing product features: unified data loading and transformation, charts in extended reality (XR), 2D and 3D desktop views, analysis and charting through a language-model assistant, immediate statistics, saved work, authentication, demo access, and shared sessions. Added concise agent instructions, targeted architecture guides, and a verification path through type checking,linting, unit tests, end-to-end tests, and live LLM tests and benchmark, then generalized the approach into codebase assessments and agentic workflows that could be applied to any repository.
• RThe prototype became a working minimum viable product (MVP) that people can use in a headset or at a desk, and coding agents can extend it through a repeatable, verified workflow.

Claude Code / Codex-style agent workflows, CLAUDE.md / AGENTS.md, progressive-disclosure guides, TypeScript and JavaScript, Vite, Three.js, WebXR, Node.js, legacy-codebase agent-readiness assessment, C++ and Python codebase variants, AI agent security and access analysis, agent tooling comparison, coverage-versus-reasoning task playbooks, refactoring prioritization by agent impact, ECharts, ECharts-GL, OpenAI Realtime / Chat Completions integration, Socket.IO, CSV / JSON / JSON-stat / Alpha Vantage loaders, persistence services

Related: Created Agentic Health principles to measure and verify changes made by coding agents, Built checks that catch false claims from language models, Built a simple file-based task tracker that agents and people both work from, Built a human-in-the-loop, automation-ready workflow from feedback to verified code, Built real-time collaborative data analytics and charting tool across headsets and browsers, Built voice-driven data exploration for immersive charts without custom menus, Built authenticated persistence with isolated user data, Built deterministic, traceable data transformations from plain text formulas, Made chart and axis selection deterministic, Kept large datasets in the browser while the language model worked from compact references, Built a repeatable Ubuntu deployment for the XR-Data-Explorer

Hide details

1 yr 4 mos · Self-employed

• CSearch results are untrusted text: they can contain hidden instructions for the language model. The assistant needed current web information while treating search snippets as untrusted and ensuring result URLs could not become server-side request targets.
• SSent queries only to a fixed Brave Search endpoint and used the returned snippets without fetching the linked pages. Stripped markup and invisible characters, capped the number and length of results, limited requests per user and across the service, and kept search off when no Brave API key was configured.
• RThe assistant gained web lookup while result text stayed short and plain, and the server never followed result links supplied by outside pages.

untrusted-input sanitization (markup, entities, control and zero-width characters), Server-Side Request Forgery (SSRF) avoidance by design, prompt-injection surface reduction, per-user and global rate limiting, Brave Search API

Hide details

1 yr 4 mos · Self-employed

• CLarge datasets, long tool responses, and repeated context make a language-model assistant slower, more expensive, and less reliable. The small model needed enough information to act without receiving the full dataset on every request.
• SDesigned each function to return compact metadata, calculated results, and a key to data held in a client-side in-memory cache. The model interpreted the request and chose a function, while the application kept the full dataset and performed the data work.
• RThe assistant could work with large datasets without sending them in full, reducing model input and leaving more room for the user's request.

OpenAI Realtime API, Chat Completions, MCP, executor pattern, DataCache, metadata-focused LLM context with client-side data cache

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend, Made chart and axis selection deterministic, Built deterministic, traceable data transformations from plain text formulas

Hide details

1 yr 4 mos · Self-employed

• CCreating and refining charts in extended reality (XR) requires controls for chart type, filtering, sorting, and visual details such as hiding labels—without filling the experience with custom menus.
• SMade voice the chart interface: the language model interpreted requests while ordinary functions created charts and applied filters, sorting, and visual changes. The same request worked in XR, 2D, or 3D.
• RUsers could create and refine charts by voice, including changing their appearance, without navigating a custom set of XR controls.

OpenAI Realtime voice sessions, OpenAI gpt-4o-realtime, Chat Completions fallback, Gemini 2.0 Flash with tool calls, LLM function/tool calling, Danish Statistics API, MCP data provider architecture, JSON-stat processing, DataCache, PlotDataExecutor, WebXR chart rendering, JavaScript, VS Code, GitHub Copilot

Related: Turned an VR prototype into a data chat (XR-Data-Explorer) that coding agents could safely extend

Hide details

1 yr · Self-employed

• CLarge datasets are difficult to investigate on a flat screen: points overlap, depth is lost, and outliers can disappear behind the crowd. Continuing an earlier Unity VR prototype, I aimed to test whether real immersive 3D exploration could reveal patterns that conventional charts conceal.
• SCreated a WebXR charting experience built with Three.js. Charts use interchangeable draw functions and are placed around the user in 3D space, where tracked controllers support free movement, rotation, pointing, and direct manipulation. Point highlighting, readable axes, in-headset panels, and a scene-level checklist support investigation from any viewpoint, while charts can be brought closer and switched between points, lines, bars, and glyphs.
• RThis became the product's distinguishing idea: exploring data by moving through it rather than by scrolling a canvas. It also left behind reusable charting and interaction pieces that later carried AI-created charts, saved work, shared sessions, and the demo films.

Three.js, WebXR, three-mesh-ui, web API data retrieval, 6DOF controller interaction, VR raycasting, custom draw-function registry, axis and label rendering, VR panels and checklist UI, Vite HTTPS development setup, AI-assisted code generation

Hide details

3 mos · Self-employed

• CGetting 360-degree photos from a camera onto a website should be routine, and the usual answer is a WordPress plugin. The plugins on offer were either too complex, missing desired features, or abandoned.
• SAssessed the available plugins, then wrote a small web module instead: point it at a folder and it presents every 360-degree image in it, with no list to keep updated when photos are added. Documented the route from capture through processing and upload to publication, and protected the images with straightforward access rules on the Apache server holding them.
• RPublishing became a matter of putting files in a folder, at lower cost and without depending on a plugin that might stop being maintained. The module itself is reusable, presenting the photos responsively on the web and in VR.

Three.js, Swiper slider, Insta360 X3, JavaScript, CSS, responsive web development, Vite, Apache .htaccess, AI-assisted code snippets

Hide details

4 mos · Self-employed

• CFlying through a dataset to find its patterns and relationships was an idea from my Ph.D project. The VR technology had matured and it was worth revisiting.
• SBuilt a Unity prototype running on a Quest 2 as an Android application: graphs drawn in three dimensions, lines between points, controller interaction, teleportation to move around, labels that turn to face the viewer, and data loaded from a basic custom xyz data format.
• RThe core interactions and visualizations worked but the software development cycle and robust updating of Unity were challenging. What it taught about controllers, movement, labelling, and getting data into a scene went directly into the WebXR implementation that followed.

Unity, Quest 2 Android application, XR Interaction Toolkit, Oculus Integration SDK, Unity Input System, C#, Visual Studio 2022, Git

Hide details

3 mos · Self-employed

• CMake data from public web APIs easier to access, transform, and explore through interactive data visualization
• SBuilt a Python workflow for the whole path: Pandas to organize the data and run the calculations over it, Bokeh to produce charts that can be explored and Matplotlib for the charts better suited to being printed than interacted with in a browser.
• RRaw API responses became charts someone can zoom into, filter, and read values from - which makes the analysis quicker and the findings easier to hand to somebody else.

Python, Pandas, Bokeh, Matplotlib, web APIs, data analysis, WordPress multilingual web page

Hide details

5 mos · Freelance

• CIn a Class C medical device - the class where a software failure can lead to serious injury or death - the strictest development rules apply to everything unless the parts can be shown to be kept apart. That separation is called segregation: a fault in a less critical component must have no route into one that patient safety depends on, and where that separation holds, the less critical parts may be built to a lighter standard. This platform needed the separation made explicit, workable countermeasures for the risks that remained, and architecture documentation describing the system actually built rather than the one originally intended.
• SEstablished where the architectural risk actually sat, then rewrote the high-level architecture documentation so that the module boundaries on paper matched what the code did, settling each difference against the implementation rather than writing around it. Compared tools able to check those boundaries automatically, so that a breach would surface in a build rather than waiting for someone to notice it in review.
• RRisk control got firmer in both places it has to hold - the architecture and the code implementing it. The regulated documentation, the real structure, and a future automated check of that structure now describe the same system.

medical-device software architecture, risk countermeasures, architecture-rule analysis, C#, Visual Studio 2022, NDepend trial, ArchUnitNET, Azure DevOps, Jira, Confluence, MasterControl document management, Git, regulated documentation

Related: Stabilized a large automated test setup, Improved medical-device testability and delivery infrastructure

Hide details

4 mos · Freelance

• CA large suite of automated tests failed unpredictably and had little documentation explaining how it worked. Getting a run started meant passing through Visual Basic, a C++ COM interface, a C# executor, and further C# and C++ executable wrappers.
• SStabilized it first with the smallest changes that would hold, then went after the cause rather than the symptom: the elaborate executable wrappers handling setup and initialization were replaced with plain PowerShell scripts. The test cases themselves were left almost untouched, so the investment in them carried over intact.
• RThe setup became stable and, just as importantly, possible to understand - with far fewer moving parts between starting a run and seeing a result. It ended up simple enough to hand over to a student assistant.

PowerShell, Visual Basic 6, C#, C++, C++ COM interface, Visual Studio 2022, GitHub Copilot, test stabilization

Related: Improved medical-device testability and delivery infrastructure, Separated a Class C medical device's software so a fault in one part cannot reach another

Hide details

11 mos · Freelance

• CUI tests required the system to be brought to a specific state before execution, making setup time-consuming and prone to errors. Firmware-to-PC communication required enhancements and bug fixes. The scripted setup of local developer and Jenkins environments was long and complex, prompting an investigation of Azure VMs. A sprint caused multiple periodic issues, which needed thorough investigation.
• SBuilt a C# tool that injects the required data directly into the database so UI tests can start from a known state. Enhanced the C++ event-based communication between firmware and PC and addressed related defects. Investigated moving Jenkins setup to Azure, and evaluated a containerized build environment. Led bug investigation across software, infrastructure, and physical test-equipment conditions. Established a systematic, documented process for recording equipment states and software issues, providing an overview that supported root-cause analysis.
• RUI-test setup became faster and more consistent, and firmware-to-PC communication issues were addressed. The delivery setup was assessed for migration to Azure and for reproducibility through containers. Work followed the existing regulated process, including requirement and test-case review, code review, and Scrum.

C#, C++, Azure, Jenkins, Docker, VM migration, containerized build environment, Visual Studio 2019 / 2022, Git, Jira, Confluence, Polarion, MasterControl document management, Scrum, code review

Related: Stabilized a large automated test setup, Separated a Class C medical device's software so a fault in one part cannot reach another

Hide details

5 mos · Freelance

• CSystem-test reporting relied on C# code writing individual Excel cells from a local SQL Express database and did not scale as reporting needs grew. Requirements from other parts of the organization had not been collected, so each new question risked creating more custom code without a shared view of what the reporting solution needed to support.
• SGathered and considered broader reporting needs, then proposed and investigated standard cloud and analytics alternatives: Azure Data Lake, Data Factory, ingestion into a SQL database, and Power BI reports carrying images. Wrote automatic test cases alongside this and actively influenced work to make test development stable.
• RReporting was reframed as an organization-wide analytics need rather than an ever-growing custom Excel solution. Test development also improved through clearer requirements, a defined architecture, written documentation, attention to regressions, and repeatable starting configurations.

Azure Data Lake, Azure Data Factory, SQL database ingestion, Power BI, Rebase Test Automation System, C#, Visual Studio 2019, SharePoint, SVN, Excel, Agile methods

Hide details

1 yr 5 mos · Freelance

• CSoftware for next generation veterinary diagnostic instruments was needed. The product needed to start from a blank state, let its separate processes communicate reliably, provide web access, and remain maintainable as the team evolved it.
• SEntire application built in Python on Raspberry Pi hardware. Collaborated in the Scrum team to develop the instrument services on Linux, with Flask REST APIs, dbus and avahi for service discovery and communication, and nginx in front. Used Docker and DevContainers for consistent development environments, pytest and Jenkins for quality assurance, and Jira, code reviews, and Scrum ceremonies to plan and deliver product increments.
• RThe team delivered reliable software. Shared tooling and automated testing made the product easier to develop, maintain, and extend.

Python, Linux, Raspberry Pi, REST API, Flask, pytest, logging, Docker, DevContainers, WSL2, VS Code, Jenkins, Jira, Confluence, dbus, avahi, nginx, protobuf

Hide details

8 mos · Full-time

• CThe startup needed a PC-based data collector that could communicate reliably with the sensor firmware while firmware development was handled by an external partner. Clear technical coordination was needed between the outsourced firmware team and startup leadership.
• STook responsibility for the overall software architecture of the product. Build a PC data collector, including serial communication, signal plotting, and supporting data-analysis tooling. Coordinated the interface and communication between the outsourced firmware developers and the startup's leadership.
• RProvided a clear architectural foundation for collecting and visualizing device data, while helping align firmware development with the startup's technical and business direction.

C++, Xilinx Zynq-7000, ARM Cortex-A9, PetaLinux, embedded signal analysis, Python scripting, NumPy, Pandas, Matplotlib, PyQtGraph, serial communication, Windows-based visualization, Azure DevOps

Hide details

1 yr 4 mos · Freelance

• CAn avionics project with more than 1000 requirements needed a systematic approach to ensure traceability from each requirement through test specification and execution.
• SRead the requirements and worked out the test strategy for each functional area together with system engineering, then wrote and revised the test cases, ran them, and analyzed the logs when results needed explaining. Coordinated with third parties over their logs and what their systems made it possible to test, and acted as troubleshooter and adviser on the test benches themselves.
• RSeveral functional areas ended up with coverage and results that could be relied on, in a programme where a test result is part of the certification evidence. Continuous integration and targeted automation carried the parts that repaid automating.

avionics testing, requirements analysis, test strategy, test-case design, log analysis, continuous integration, test automation, Python TCP/IP client-server tooling, Perforce Helix

Hide details

7 yrs 10 mos · Full-time

• CDeveloping features for large two-stroke marine diesel engines required carrying requirements through design, implementation, testing, and commissioning on the engine. Delivery was slowed by incomplete design and code documentation, inconsistent configuration handoffs between departments, and manual system testing that depended on scarce hardware and individual experience.
• SOwned control-system features from requirements through C++ design and implementation to commissioning. Improved software-development workflows by strengthening design and code documentation, and improved cross-department configuration processes to make integrations and releases more predictable. Built and automated hardware-in-the-loop system-test setups with LabVIEW and purpose-built tools, including generation of system test specifications supporting re-use.
• RDelivered commissioned control-software features with a more repeatable path from requirement to engine operation. Automated hardware-in-the-loop verification reduced reliance on manual test execution, while improved documentation, configuration workflows, and reusable generated test specifications made development and testing easier to maintain across projects and teams. Close collaboration with development and test teams in India.

C++, control systems, requirements specification, commissioning, LabVIEW, TestComplete, Sequanto SeqZap, JavaScript test scripting, XML, XSLT, HTML, CSS, Perl, Boost, GDB, AsciiDoc, PlantUML, Doxygen, Synergy, Documentum

Related: Modernized operator screens, charting, and alarm-data maintenance for engine control systems

Hide details

1 yr 3 mos · Freelance

• CThe screens an engineer watches an engine through, and the alarm data behind them, needed continued development on an established C++ and Win32 application. Rewriting was not on the table: this software was already in service, and the work had to add to it without disturbing what ran.
• SDeveloped and maintained the touch-screen operator interfaces, and added XY charts so collected data could be read as a trend. Maintained the alarm database, chose the tool for comparing database versions.
• ROperators could see how a measurement had been behaving, not just what it read at that moment, and the alarm data that the engine's warnings depend on stayed maintained and correct in a long-established industrial system.

C++, Win32 API, Borland C++ Builder 6, CppUnit, IoComp Plot Pack, MS Access, Synergy configuration management, TestComplete, Doxygen, Scrum

Related: Developed control software and automated testing for large two-stroke diesel engines

Hide details

6 yrs · Self-employed

• CCustomers had varied software requirements across desktop, client-server, web, and CMS applications.
• SProvided end-to-end freelance software delivery tailored to each customer's needs.
• RSix years of client software built and kept running: command-and-control systems, a communication framework for hearing instruments, web and CMS delivery, and client-server applications.

.NET 2.0 / 1.1 / 1.0, C#, C++, VB, XML, XSLT, ASP.NET, Sitecore CMS, NUnit / MbUnit, TestComplete, MSBuild, Domain Specific Language tooling, Visual Studio 2005, SourceSafe, ClearCase

Related: Developed a large scale control and command system for a defence supplier

Hide details

1 yr 2 mos · Freelance

• CAn ad hoc developed prototype caused multiple errors when new features were added. The large scale control and command system must be well-architected and implemented as a client/server application on .NET. The project used the V development model, requiring designs to be specified and documented before implementation
• SFocus on unit testing and test coverage. Maintain alignment between design and implementation by reviews.
• RReliable code changes, developers could navigate and understand the system more easily.

.NET, C#, object-oriented design, UML, Rational XDE, NUnit, ClearCase, Visual Studio 2003, V development model, client/server architecture

Related: Ran an independent software consultancy across full delivery lifecycles

Hide details

3 yrs 2 mos · Industrial Ph.D

• CThe displays an operator watches an industrial process through were designed largely by ad hoc judgement and precedent (mimic PID diagrams). There was no systematic way to decide what information the operator needed for a given task, how to present it, or how to assess whether the presentation was effective.
• SAnalyzed what makes display design difficult, developed a method for approaching it, proposed new visualization techniques, and built working prototypes presenting real process data graphically. Assessed the multimedia technologies of the period for what they could contribute.
• RThe research produced a method and a set of guidelines for designing displays that industry could apply, and it laid the foundation for my continued work in human-computer interaction, visualization and control systems. The prototypes demonstrated the method and the techniques, and they were used in real industrial problems and were integrated into the company's product line.

human-computer interaction, man-machine interface, display-design methods, visualization techniques, industrial research, process-data visualization prototypes, ActiveX, VB / VBA, Win32 API, multimedia technology assessment

Hide details