Many technologies are discussed in the ROUGOL talk, both those that are used, and which were created or updated during the project. Some of these technologies are available to the public. The technologies that were used for a project are always interesting.
2020Source control managementI use a self-hosted GitLab on my own server. It's got some publicly accessible parts, but most is private.
2020Cross-compiling toolchainTo build my own RISC OS components on modern systems, I needed to port the Norcroft compiler and the related toolchain to work on 64bit Linux and macOS.
2020Rosetta Code extraction toolTo test the compiler, I needed some C code. I built a tool that would allow me to download all the example code from the Rosetta Code website.
2020Software repositoryI use Artifactory for storing software components.
2020Docker RISC OS development environmentI created a small RISC OS docker containers for use building RISC OS components, using the cross-compiling tools.
2020Automated testing internallyI use GitLab CI triggers on every change. This pulls resources from Artifactory, builds, then pushes results up to Artifactory.
2020/2021Automated build and testing for others
I built JFPatch-as-a-service as an aside to make it possible for others to build RISC OS components online.
The system itself uses a number of technologies:
- AWS services are used for the front end (SSL, DNS, CDN), and back end (SSL, Load balancing, virtual host).
- CodeMirror is used for code editing, customised by modes for JFPatch, ObjAsm and BASIC.
Open source: CodeMirror modes for RISC OS
- The back end parses RISC OS Zip files using a Python module.
Update (2021): Improved handling of zip archives, and a way to invoke from the command line.Open source: Python ZipInfo for RISC OS Zips
2020SimpleYAMLParsing YAML using the common YAML parser would mean requiring an external module - and one that would require compiling. I created a more limited and easy to drop in parser.
2020StreamedInputI have needed a way to run commands in the background and collect the output in a safe way, a few times. For JFPatch-as-a-service, and for host commands in Pyromaniac, the StreamedInput module provides the interface to the command systems.
2020Build client for JFPatch-as-a-service
robuild-client is a client for Linux, macOS and RISC OS which can submit sources to JFPatch-as-a-service for building.
The client itself is based on a 3rd party JSON library, and a 3rd party WebSockets communication library, both of which I ported to RISC OS for this tool.
2020/2021Presentation toolTo present the talk, a presentation tool was created to run on RISC OS. This used a number of technologies:
- The presentation tool itself, written in C.
Update (2021): Small update to include quoted sections and better handle wrapping.Open source: Present tool (source)Release:
- Port of a Markdown parser.
Open source: MD4C for RISC OS
Reused the FontMap technology that was created for the WMF render.
Reused the WebColours technology that was created for the SVG converter.
Reused ImageFileRender for general image rendering.
2020OSLib parserOSLib provides definitions for many of the RISC OS interfaces in a well structured way. I needed a way to parse OSLib files so that I could use the definitions, and the OSLib code itself does not lend itself to being re-targetted.
2020/2021RISC OS Alphabets for PythonRISC OS Alphabets are not quite the same as the international standards, so I have codec modules created for the RISC OS Alphabets.
2020/2021Non-RISC OS editor syntax modesEditing RISC OS files on non-RISC OS systems means not having context colouring, which is sad, so I created some colouring definitions.
2020/2021Hourglass makerI wanted to create an hourglass module. Before I did so in Python, I created some modules in assembler. But in a nice generic way so that I could turn any image into an hourglass.
2020/2021Tests for RISC OS APIsSome of the test for Pyromaniac are available for others; or for others to submit more.
2020/2022Documentation systemAs part of the work I was doing, I had to document some APIs, so I resurrected the PRM-in-XML templates.
2020Tun-Tap JSON serverFor testing the network stack with Ethernet drivers, I needed a way to connect multiple clients together. I created a simple TCP service which clients can connect to, which distributes Ethernet frames. The service can be attached to a tap, and thus bridge on to real networks.
2020Toolchain updatesSome parts of the toolchain were updated, although there's not a lot to say about them.
I created analogues of the RISC OS
destroy tools so that
I could build on RISC OS and Unix systems in the same way.
I needed a BASIC tokeniser so that I could handle storing files in git sensibly, and editing them on other systems. The tokeniser needed to be able to run on RISC OS and other systems, and I didn't want to compile anything. The code I'd previously written for HdrToH was a good starting point.
2020Changelog managementFor my own use I wanted to manage the changelogs in a better way - particularly avoiding conflicts when merging branches.
2020/2021/2022Examples of the use of RISC OS APIsExample programs show how the interfaces can be used.
Font_Paint examples updated,
together with the Portable module.
2021Font string qualifier parserTo make sure that the font qualifiers are processed properly, the parser was implemented in a separate module. This allows it to be tested more easily.
2021Font control code parserLike the font qualifier parser, the control code parser was implemented separate module and tested to make sure that it was working properly.
2021XML2 library port (XMLLint)Back in the early 2000s the XML2 library was ported for use with the PRM-in-XML project. This port has been brought up to date with the latest version.
2021XSLT library port (XSLTProc)Back in the early 2000s the XXLT library was ported for use with the PRM-in-XML project. This port has been brought up to date with the latest version.
2021DebugIt moduleDavid Thomas was trying to debug the WindowManager, so I dug out my old DebugIt module which writes to SysLog.
2021StrongHelp manual extractorI needed to read some StrongHelp manuals, so obviously I wrote an extraction tool in Python, rather than run the application on RISC OS.
2021VNC server for Cairo surfacesTo make it possible to share the RISC OS Pyromaniac interface with others, a Python library was created to allow the Cairo surface to be served over VNC.
2022StrongHelp manualsLong ago, I produced a StrongHelp reference manual for RFCs. The manual has been rebuilt from the previous scripts and released as an open source repository.
2022Version managementIn ancient days in other lives, long past, but not forgotten, there was a script called 'srccommit'. This was used to commit code to the CVS repositories used at Acorn, together with updating the necessary
which tracked components. At RISCOS Ltd, I created a 'commit' script which worked
in a similar way. This script is still available on my site. With the advent of git, there's less need to manage
committing in as structured a way. But managing the
is still important. The 'vmanage' script can do this (for C, assembler, and BBC BASIC).
2022Joystick driverI made one of my old Joystick modules available as open source. This was a simple interface to an Atari 9-pin joystick, using the parallel port.
2022IconBordersFollowing some discussion of the very limited interface for customisation of buttons in RISC OS 5, I open sourced my example IconBorders modules from the original SDK. The example module includes documentation on the API used. An additional 'fob' module was also released which demonstrates a slightly different style of buttons.
2022Portable moduleDuring development of RISC OS Select it was expected that there would be portable devices coming from hardware manufacturers. As I did not want to have more assembler code being written, and to make it easier to work with the modules, a prototype Portable module was created in C. This module just needs a few functions replacing to perform as expected. I realised this module as I was seeing a few portable devices appearing, and I assumed it unlikely that any work had gone in to making maintainable modules for them.
2022Jan Vibe graphical dittiesJan Vibe wrote some great BASIC programs that demonstrated many features of the graphics system. They were a great test to exercise rarely used interfaces and provide examples of how the systems should work.
2022FanController stackThe FanController stack is small - a controll and a number of drivers. I created the modules to make it easy to add controls for hardware fans. The open source repository contains both the source for the FanController and an example module that you can use for your own hardware.
2022RISC OS build service examplesThe example code used in the RISC OS build service is available as a separate repository which may be easier to browse.
2022RISC OS-like file explorer in WxPythonThe WxWidgets user interface in RISC OS Pyromaniac provides an explorer for the files in the emulated system. This file explorer isn't actually specific to RISC OS Pyromaniac, although that's where it was written for. The implementation is generic enough that it can be used as a separate interface to a real filesystem, or to a virtual filesystem in a similar manner to Pyromaniac.
2022Memory dumperThe memory dump code used by RISC OS Pyromaniac is used by the
implementation in Debugger, and the tracing code. To make it easier to work with,
debug and maintain, the dumping code has been extracted into its own library. This
library comes with a WxPython frame implementation as well.