A NodeJS + ccjson based playground for playing with declared software systems. Even the smallest program or snippet of code can grow into an expansive system over time. As code grows it becomes rigid and looses potential, something declarative system composition can potentially address by ensuring it is easy to swap out any component or aspect at any time.
The problem is that creating systems built from vast declarations can be very hard if you actually want them to stand up to this lofty goal without becoming enormously abstract and heavy.
Playlets provide the perfect venue for experimenting with how to build systems declaratively as each new playlet is a fresh minimally-structured space full of potential that can be expanded in any direction you see fit to try out a new approach or application.
You may have never heard of the concept of declaring software systems before. That is likely because it has taken until now for the needed open source software concepts and implementations as well as communities and understanding to evolve sufficiently.
In playlet speak, a Playlet (Declared Software System) is code that:
- Downloads, Provisions and boots itself using only one command and a private key.
- Touches no path outside its root unless it is a spcific feature.
- Manages its own runtime lifecycle and data completely privately.
- Declares all external resources interacted with
- Is reconfigurable and patchable 100% by overlaying configurations prior to runtime.
- Respects namespaces and does not conflict, block or expose without permission.
- Prompts for credentials via an encrypted API as needed.
- Exposes its internal workings via a conditional log stream.
You don't need to worry about how to build a system to meet the above criteria because playlets come pre-seeded as complete mini systems that meet all the above criteria in the form of a reference implementation with adapters.
You just start with the basic seed and take it any direction you want while sticking to the rules above. The rules are critical to keep your playlet alive, sharable and extensible by machine logic and human thought.
As for time allocation, replace all time you spend on repetitive code production overhead (documenting, tasking, communicating, training) with time spent on building playlets to automate these tasks and re-use them in a configurable way in other playlets. (i.e. generate all kinds of assets from the same dense source logic and use APIs to orchestrate all information and events surrounding the codebase)
Do not worry about breaking API backwards compatibility when charging ahead as long as you use a continuous data model. The whole point of playlets is to drop prior investments into structures and start in new directions. Playlets are stabilized through continuous testing on every change which means all expectations must be clearly declared and will thus become available to tooling. Playlets broken after changes should be repaired until they eventually become obsolete and age out.
Defines list of possible properties and provide protable utility libs.
- NodeJS Application
Each stage has different properties and capabilities needed for different kinds of scenes.
Each stage has an adapter:
- Heroku
- Circle CI
- Browser Page Component
- Browser Extension Component
- OSX Desktop
Scenes hold source logic that orchestrates characters into a continuous dance. Unlike in real life, many scenes can run at the same time.
Source Logic is ideally devoid of imperative instructions (other than in portable formats without wrappers) and instead maps acts into a cohesive whole.
Light virtual config layer.
Characters embody performers based on given specific properties, capabilities and own relative positioning in the character and feed them adapted source logic that was generated with other performers.
Characters react to events in Scenes.
Light virtual config layer pointing to assets and can all be bundled up.
Each input and output for each act is a static asset.
- 16.01 - HTML5 code to desktop app
- 16.01 - HTML5 code to browser app
- 16.01 - Express style middleware responder
Performers bring to life plays by traslating and transacting source logic into different languages and movements.
- NodeJS to Docker converter & runtime shim
- Babel Translator
- git wrapper
An actor may be a playlet itself.
Performers react to events in Characters.
Performers declare:
- Code dependencies
- Required and optional usable properties
- Required and optional usable capabilities
Anything needed for a Performer to do its work.
Assets created while playlet is running.
Original source logic under Free Public License by Christoph Dorn