# playlet

> Playlet =======

Latest version **0.1.0** (published 2016-01-27) · 0 weekly downloads

## Install

```sh
npm install playlet
pnpm add playlet
yarn add playlet
bun add playlet
```

Provides the command `playlet`.

## Health

**Score 10/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; low quality score; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.0 |
| Published | 2016-01-27 |
| First published | 2016-01-27 |
| Weekly downloads | 0 |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | cadorn |

## Links

- npm: https://www.npmjs.com/package/playlet
- npm.io page: https://npm.io/package/playlet

## Recent versions

- 0.1.0 (latest) — 2016-01-27

## README

Playlet
=======

A [NodeJS](https://nodejs.org/) + [ccjson](https://github.com/LogicCores/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:

  1) Downloads, Provisions and boots itself using only **one command** and a **private key**.
  2) Touches **no path outside** its root unless it is a spcific feature.
  3) Manages its own **runtime lifecycle** and **data** completely **privately**.
  4) Declares all external resources interacted with
  5) Is **reconfigurable and patchable** 100% by overlaying configurations prior to runtime.
  6) **Respects namespaces** and does not conflict, block or expose without permission.
  7) **Prompts for credentials** via an encrypted API as needed.
  8) 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.



Notes
=====

Paradigms
---------

Defines list of possible *properties* and provide protable utility libs.

  * NodeJS Application


Stages
------

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
------

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
----------

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
----------

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


Props
-----

Anything needed for a Performer to do its work.


Recordings
----------

Assets created while playlet is running.


Provenance
==========

Original source logic under [Free Public License](https://lists.opensource.org/pipermail/license-review/2015-October/001254.html) by [Christoph Dorn](http://christophdorn.com)

---
_Source: https://npm.io/package/playlet · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
