examples of meta-services

[tballmsft]

A meta-service is a service defined in terms of other services. Example

• composite
  • color picker: this Jacdac widget uses three potentiometers (R,G,B) and an RGB LED to allow the user to create a color;
  • three buttons: special event when all three are pressed
  • gamepad <-> buttons + joysticks
  • traffic light <-> 3 LEDs
  • traffic light + state machine (allowable light transitions)
  • push button encoder <-> encoder + button - where the composition may be greater than the sum of its parts
  • classify various kinds of composition
    • set union
    • set union + behavior among set elements
• adapters
  • button stack (streaming state -> edge detect -> gesture detect)
  • the LED stack (binary -> dimmable -> RGB).
  • adding new functionality to a low-level service (edge detection)
  • morphing one service into another (button as shake event of accelerometer)
  • thresholding
  • types of adapters
    • raising level of abstraction
    • casting (button as accelerometer, or vice versa)
    • performance tuning (tier splitting)

[ducky64]

Possibly ties into the testing discussion, #505

Additional adapter thoughts

Functional composites / devices (compared to simple composites, which are just

• HSV color picker, using a rotary encoder, pushbutton (cycle between H/S/V), and LED ring. Could be used in place of a RGB slider device.
  • Could either be a whole device (eg, all those on one PCB with a single JACDAC connector - which could also be unbundled into its component services), or assembled from pieces as a software adapter.
• Number entry, like one might see on electronics test equipment
  • 7-segment display + up/down button
  • 7-segment display + up/down button + digit increment (say, move left)
  • 7-segment display + up/down button + left/right digit select
  • Any combination replacing the 7-segment display with any other display, or replacing the left/right digit select with a rotary encoder. Bigger picture: maybe an abstract number display service, and an increment/decrement service?
• Observation: this starts to get into dataflow programming, where devices can be created by composing these functional blocks. How does this play with the more imperative programming paradigms (including Blockly-style block programming)? What might be a sufficient library of blocks to be able to do serious operations in a dataflow "language"?

Level-of-abstraction adapters

• Neopixels: lowest level of abstraction that is a streaming buffer, with animation layer on top with a higher level programming API and bandwidth reduction (if this runs on the module - so the streaming buffer 'communication' is on-chip)
• Displays: lowest level pixel buffer, with 2d graphics layer on top (line, rect, maybe circle), with widgeting layer on top (TBD: what this API even looks like)
• Observation: can expressive type systems avoid code duplication here? Eg, there's many variations on displays: one-bit, greyscale, color (with varying color depths, if we care).

Prioritization framework

This section WIP

Basic set of adapters (plus associated service definitions)

• Button edge -> gesture detection
• Button streaming value -> edges
• Capacitive / analog button streaming values -> button streaming (binary) values
• Traffic light simple composition
• Gamepad simple composition

More interesting set of adapters (plus associated service definitions)

• Separate Neopixel buffer and animation layers
• Separate basic LED and animation layers
• Functional composition adapters: color picker with R/G/B sliders, maybe also with H/S/V encoder
• Functional composition adapters: maybe number entry

Might-not-be-practical-yet set of adapters

• Display stack (needs a display service and ideally boards; widgeting API needs serious design thought)
• Syntactic sugar / automation for simple composition adapters

Overarching task tracker

• Build adapters using jacdac-ts and JDOM, driving underlying infrastructure changes.
  • Button Gesture Detect
• When VM is ready: migrate adapters over to VM
• Any additional implementation to support adapters in VM, eg transpilers
• Think about advanced type constructs for deduping adapter code