Quickstart Contribute elioWay

elioWay

It's 2023 and we still have to explain to a computer what a Person is. These are our future rulers and they don't know what Person is! Tim Bushell

A Return to Paradise

Are you an application developer who, like me, is bored-witless writing the same boilerplate code, over and over again? Do you groan at the thought of building another form... rewiring validations... marshalling the onSubmit package just to capture the same old data? Does the mere idea of writing out yet another set of models for a pretty standard application darken your mood?

Help complete and improve the elioWay - a library for rapid application development; iteratively reusing a single methodic, mnemonic design_pattern modeled on SchemaOrg types.

Build applications faster with little to zero boilerplate code: Especially microapps, SPAs, webpages, components and other services with a similar footprint. Have reusability built into everything you do.

Use it to build your next client's project in a few hours, not days - or in minutes, not hours.

Neither new, nor complicated

That's straight-up one to many! Every developer ever

We are the first to admit it. This pattern is neither new, nor complicated. It's basically one to many.

We call the "one" in this relationship the engaged thing. The "many" is what we call: the list.

All these records will be modelled on http://schema.org Things. Each App is for dealing with one engaged instance of a Thing and all the other "things" in its list.

Everything a developer needs to manage their data structured in the pattern described above will "come out of the box" in the elioWay, but you might have some specific features in mind for the application.

For example, in way you report on the information extracted out of the relationship between the engaged Thing and its list, or between any item in the list and the rest of the list. Maybe you need a custom widget to handle date entry?

This is where you start coding in the elioWay (all the CRUD is done for you) and we call this stage optimise.

That's the design_pattern - a standard way of structuring and building applications spelled out by the letters of our way whose data is modelled on Schema: e l i o

Features

Free Data Models!: Data is modeled on Micro Data Schema from https://schema.org. MDS offers a ready collection of schemaTypes, like Person, Place, Restaurent, EmailMessage, Event
Search Engine Optimized: elioWay applications publish their data in the correct format with MDS by default.
Applications are "legoey": An elioWay application can be for any one or combination of those schemaTypes OR elioWay applications - so each app can be combined with other apps.
Every Thing is an App: When you engage some Thing in the list, you are not merely accessing data inside the using currently engaged app... like opening a .doc file in MSWord. You are Engaging another App. That app may or may not have the same features as its host.
Every App can read any Thing: Every App will know how to read *the elioWay data structure. In this way, the same data object can be engaged in different ways by combining it with different apps.

TLR

The elioWay

To control the work flow and cope with the modular approach, the elioWay repository is split into GitLab groups.

Who is this for?

Developers can help us build a library of common code which they themselves can use to shortcut many types of applications and websites you build every day.

Startups can use it to showcase prototypes quickly.

Content Creators can format their media and text the elioWay - then use any app from the elioVerse to publish it... for instance tiktokTheElioWay, or faceBookTheElioWay, or myCustomAppTheElioWay.

Small business can use it to spin up micro apps for dealing with a short term problem... like a parents group organising a one off bake sale for some school trip - or as simple as spinning up a specific order with an invoice for a particular customer.

AI developers can train their minds with it - it's very atomised and easy to grade. If I knew AI, I would write tests for my endpoints - tests for training - AI can write code.

What do elioWay apps look like?

Data

The data - the Thing - might look like this:

{
  "name": "AppName",
  ...ThingProperties,
  "Place": {...PlaceProperties},
  "Hospital": { ...HospitalProperties },
  "Itemlist": {
    "itemlistElement": [
      { "name": "Item1" },
      { "name": "Item2" },
    ]
  }
}

Code

The application logic - the Bone - might look like:

{
  potentialAction: (thing) => thing.potentialAction !== "OK",
  Itemlist: {
    All: (itemlist) => itemlist.filter(),
    Completed: (itemlist) => itemlist.filter(completedFilter),
  }
}

Template

The template might look like:

{
  "name": { "believer": "h1" },
  "description": { "believer": "p" },
  "status": { "believer": "dl" },
  "Itemlist": {
    "name": { "believer": "h3" }
  }
}

Appification

And it would all come together like this:

import { elioApp, ElioThing } from "theElioWay"
import thing from "./thing.json"
import bones from "./bones.js"
import flesh from "./flesh.json"

let PromotionsThing = new ElioThing("Event", { list: ["Product", "Place"] })
let BusinessThing = new ElioThing("Business", {
  list: ["Person", "Product", PromotionsThing],
})

let app = elioApp(BusinessThing, thing, bones, flesh)
app.run("localhost", 5000)