The existing tools in the cooperating system provide most of the instruction primitives needed to do most things though there may need to be some more discovered.

Filter

As we know the everything is a list, including Mods. With all lists you should be able to sort and filter.

Like with QuadSpinner Gaea you can reorginize your panels by adding a sort or filter to your view.

You can build a sophisticated filter that simplifies the instruction for an overview map but it’s not just a graphic but is the code with unimportant parts hidden. You could stylize this or even apply the values to front end sliders or other controllers.

Also because you can clone a value using connections into you mods, you could write an unrelated document like in the Tydlig App example. Then if a value in it is changed in the future it could affect a mod than references that value.

With sophisticated filters you can actually code horizontally or classically with search based text entry and it will convert it into mods.

Scale

Like with all scalable UI a panel should be able to collapsable into a single symbol state with combined connections. In QuadSpinner Gaea they stay zoomed out and use a separate panel to show the definitions of the scaled down panel that is selected.

Humble Interface

The Humble Interface Principle says one workflow isn’t superior to the creator. You may plot out the connections first and then define them later or define them first and connect them later. In QuadSpinner Gaea they draw a connection from a panel and drop the other end in mid air. They then could choose from a list of definitions to connect this too. We could also just leave the connection undefined for later.

Procedural Generation

Beyond just a simple if this, then that, we will be able to stack many “then” instructions together to produce long lists of automated procedures including modeling shapes like Rhino Grasshopper.

Mods can push any button or input any value a human operator can.

Connection Mode

Connections can do different things based on their mode;

They could represent the Flow of activity or history and even animate that flow.

They could Mirror a value from one definition to another and even do this wirelessly like a radio tuning into it’s UID#. This is my favorite as it has been proven to be intuitive.

They can also represent Meaning such as a note or dictionary or make up a web of knowledge.

Ports/Sockets

Sockets should not be externally displayed but contained following the Interface Card Designs that help with visual association. These will appear sunk and scaled out in as another column of data or as a sunk in value itself.

Though they can, sockets don’t need to be visible all the time but only when using a line to connect them so it’s obvious where you can connect or drop a mod part.

Just like how abilities should be separate value from the character’s appearance, sockets should not be typed, rather connection line modes should define how a socket is used. See Figma Coding Concept how some sockets are for specific modes which is bad by default.

Lines/Connections

There can be many things a line can be used to say;

List,

Order,

Relation,

Tag,

Flow,

State,

Meaning

Mix,

Copy,

Inheritance Direction

...

Panel Mod Parts

You could either

Exhaustively have placeholders with all 4 parts already in a panel

Or minimally you could assemble a Mod from scratch.

Or flexibly you could keep mod parts as separate panels connected by lines rather than cards.

Pause

You should be able to disable/pause Mod Parts individually, the when condition so it’s not wasting any compute time checking for the trigger, and the do effect so you can observe/log the when condition being triggered without it actually doing the effect.

Group/Card

As you can see in Facebook Origami, you can group mods inside cards to visually seperate/associate them.

You can connect out ports to the edge of a group card to make it easier to access internal values of importance.

Selection

Notice Enso’s selection where the cursor becomes the selection highlight as you hover over an item.

Naming Standards

Ports, Sockets

Mods, Instructions

Cards, Panels

Primiteves

Meaning

Wire, Connection, Cable, Wireless,

UID, Value

Mod related standards

Libraries (list of mods)

Mod

Skill

Measurement - Action

When - Do

Condition - Function

Operators (Changable values in a mod)

Cause - Effect

If - Then

Logic

Process

List

Logic Table

Array

Node Appearance

It cannot be radial because there then would be a finite amount of connections.

Mod Lod

Is it possible to run mods live at a highlevel during interaction and then use a baked assembly version when not. Sort of like LOD for code

Compiling is converts to assembly before started

Interpreting is converts to assembly when started

Jit is just in time compiles while running

Collapse/Combine Group

Any group of Nodes could be collapsed into a single Node listing all the values, inputs and outputs except those between the nodes grouped.

Template Inheritance

Content Inheritance

I have an idea where you fill out The details on the panel but if you choose to use a different panel it will subplant your details onto it so all alternative versions of your class are interchangeable in large.

This would allow you to use an array do type and fill out the parameters, then change the so type to another variant of the array or an outline and it will fill in those same parameters as far as possible.

How should we do reverse inheritance where you make a class use it on a bunch of code and then make a new class use it up on a bunch of code and then decide you like it better and want to implement it across all of your content that uses the first type of class. But don't want to have to do it manually. Supplanting values will let you do this. Also it would help when you're making a class instead writing out the name of the class function you point at a function that already exists in another class so that if you want to trade it out later it knows to pull the value that's assigned to that function.

Node Wrangler Inspired Features

Many of these features could be implemented by users from within CoOS or global features already usable in this way.

Preview the output of a node

Isolate the output of a node

Simulate input of a node

When drawing a line, where you let go could open a context menu listing the possible ports you may have wanted to connect it to so you dont have to be to precise initially. I want to implement this globally for letting go of a draw.

User provides an example of connection and then repeat this example on selections. This example sampling feature could be made global.

Copy node with connections so inputs are sourced from the same outputs that were sourced for the original node.

Frame/Group Nodes, recolor,

Align Nodes to keep tidy, this would be a global measure>align feature that can be used here.

Refactor

Code Smell

These are features of code that add up to reasons for refactoring.

Here’s 5 categories.

Bloaters

Bloaters are code, methods and classes that have increased to such proportions that they are hard to work with. Usually these smells do not crop up right away, rather they accumulate over time as the program evolves. For example: Long Method, Large Class, Primitive Obsession, Long Parameter List, Data Clumps.

Object-Orientation Abusers

All these smells are incomplete or incorrect application of object-oriented programming principles. For example, Switch Statements, Temporary Field, Refused Bequest, Alternative Classes with Different Interfaces

Change Preventers

These smells mean that if you need to change something in one place in your code, you have to make many changes in other places too. Program development becomes much more complicated and expensive as a result. For example: Divergent Change, Shotgun Surgery, Parallel Inheritance Hierarchies

Parallel Inheritance Hierarchies

Dispensables

A dispensable is something pointless and unneeded whose absence would make the code cleaner, more efficient and easier to understand. For example: Comments, Duplicate Code, Lazy Class, Data Class, Dead Code, Speculative Generality.

Couplers

All the smells in this group contribute to excessive coupling between classes or show what happens if coupling is replaced by excessive delegation. For example, Feature Envy, Inappropriate Intimacy, Message Chains, Middle Man, Incomplete Library Class.

Incomplete Library Class

Smell Proof

Refactor Assistance

Another option if smell proof code is not possible, is to help in the refactor process.

Problems with Classic

Memorization vs Readability

One problem with programming language intuitiveness is that all the components of a line of code are not individually labeled you just have to memorize what goes where and why and what it will do and what's important. Mods fix this.

Benefits with Mod

The ability to map the code reorganize it on the fly

404

Never a broken link

Because a link is connected to the ID of the object at a certain point in time which is never deleted so even if it's removed from space it can always be found with its links unlike websites where links break 404 all the time.

Reference the same comments from any node. In classical coding you can add a comment above or beneath code but not tie it to the code directly nor will that comment appear when a variable is used elsewhere. Mods fix this.

Mod Challenges

Data visualization,

editing to useful form,

analyzing,

Thresholds

Race condition,

deadlocks,

locks around critical sections,

distributed systems,

uncertain communication/readyness

Error checking

Simulation

Test Design

What Irritates Programmers the Most

1. Code of other programmers

Nothing — nothing fills a developer’s heart with as much hatred as the knowledge that he/she has to look into code written by someone else.

Compared to this operation, the insemination of cattle without rubber gloves seems like a simple tea show. Amidst hellish torment, one has to understand someone else’s neck-wrapped wit, see through their algorithms that are frivolous and completely different from his/her own sophisticated and noble thinking. Some programmers can only do one thing in a situation like this — erase it and rewrite it all.

3. Writing documentation

If the specification required is bad, then so is writing documentation. Why describe an existing software? What do you do when the source code is already there?

Fortunately, writing documentation usually happens after the coding is done. If you have to do it anyway, it’s not worth spending too much time on it. In the first three years at the earliest, it will need to be edited, and by then, the original creator will be long done with the project.

Theory

"The Future Compiler will be more like a search algorithm, you give a specification and the compiler looks through hundreds of useful implimentations of your specifications rather than 1 to 1 steps". -George Hotz

Imperitive

Functional

Veralog sequential instructions

Pytorch machine learning

"Learn programming by trying to do a project rather than a video."

"Assembly so you can understand what the machine is doing.

C so you can appreciate what it does over assembly.

Python so you can appreciate it over C"

Examples

A List of No/Low/Visual Coding Examples found at hopehood or fullscreen.

We will progressively organize and reference these examples further.

Unthought

Help

This needs to be easily accessed for each item in list so it is easy to see what each function does and how to use it.

Tour

What if the system could give a guided tour of Mods automatically. It could take multiple passes for each level of abstraction or offer twistaplot choices as you tour. You could even tour a section wherever you are.

This solves readability.

Logic Wizard

I think even a spreadsheet of 1s and 0s will be to complicated and literally looks like code which is against Mod Principles.

I propose a wizard that turns creation into a step by step q and a.

I propose that wizard also displays the logic as it goes in a more readable obvious manner.

2D lists(spreadsheet) is the minimal view of logic

and you could use that optionally but another option should be this

Wizard or selecting already created logics which can display as either List or Wizard.

Wizard Wizard

Freeform

While spreadsheets ond other list cards can constrain with spaces and indention we can alternatively freely move contents like anything else.

I need to develop custom lines in spreadsheets that can cross over other cards(cells) but could only effect specific rows and skip over others...

This design will probably move over to “coos design guide”.

Colors

Why are there no colors in Mod?

This is because we want to save the colors for you.

You could use them to show programming elements like statements and objects...

or you could use them to highlight what will occur if you drop what you have in that place.

or you could highlight what still yet needs definition or what has automatically been defined.

But if we highlight everything nothing is highlighted.

#HumilityPrinciple

Nested Mods

Make mods groupable and then you could hide any elements so as it scales down the important elements remain. This is a system wide feature of CoOS already.

Making it readable to see what a mod does.

Comment Everything

Using the meaning engine we need to be able to add meaning to empty space, values, types, use cases, everything...

In classical coding how would you comment on a variable so that you could read the comment every time that variable was used? Super long variable names?

“don’t use comments to explain the what. Instead, use them to explain the why, and only when you can’t convey the why through naming.”
Comments can be redundant or misleading after refactoring code without updating the comments.

Bad Example

# Seller is eligible to be paid under the following conditions:

# 1. It's past 2020/5/1 when we got legal approval to make payouts

# 2. It’s Nov/Dec since those are the only months eligible

# 3. User is not from list of countries that are banned

today = date.today()

if today > date(2020, 1, 1) and (today.month == 11 or today.month == 12) and user.country not in ['Narnia', 'Odan', 'Maldonia']:

# This function does the actual payout by calling Stripe

# It saves the response asynchronously.

payoutHandler()

Good Example

PAYOUT_APPROVAL_DATE = date(2020, 5, 1)

BANNED_COUNTRIES = ['Narnia', 'Odan', 'Maldonia']

NOVEMBER, DECEMBER = 11, 12

ELIGIBLE_MONTHS = [NOVEMBER, DECEMBER]

today = date.today()

is_past_approval_date = today > PAYOUT_APPROVAL_DATE

is_eligible_month = today.month in ELIGIBLE_MONTHS

is_user_from_banned_country = user.country in BANNED_COUNTRIES

if is_past_approval_date and is_eligible_month and not is_user_from_banned_country:

stripe_payout_resp = callStripeToPayout(user)

saveResponseAsync(stripe_payout_resp)

Indirection

Indirection is a computer programming concept that describes a computer's ability to reference a value through a name or container, rather than the value itself. Each time that a value is referenced through such a name or container is known as a level of indirection.

Term Comparison

Here I want to make a chart of programming language terms that mean the same thing.

http://rigaux.org/language-study/syntax-across-languages.html

https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(syntax)

Term Library

Here are the definitions of all the programming terms.

Code Parts

Critics

Most professional programmers will be continually abstracting and decoupling code. Indeed, the difference between good and bad code is essentially how well this has been done. Visual programming tools rarely have efficient mechanisms to do this and essential trap the developer in an equivalent of 1970’s BASIC.

read a typical program written in a standard textual programming language and imagine it transformed into graphical elements of boxes and arrows. If you do this it soon becomes apparent that a single line of code often maps to several boxes and since it’s not untypical for even a simple program to contain hundreds of lines of code, this translates into hundreds or even thousands of graphical elements. The effort to mentally parse such a complex picture is often far harder than reading the equivalent text.

When you combine things it just chooses a method of combination based on various factors like your preferences, context or prediction, but you can open up what it chose and change it later.

Draw programming languages parts like classes methods libraries functions... And show the differences between them and mods.

Libraries aren't needed because of the shared files system.

Value ‘Types’ are used by programming languages to cheat letting the compiler do some reasoning about what you expect it to do. Try very hard not to use types because that reasoning should either be specified by the user, safe default interpretation, or higher level reasoning later on through AI.

If types were necessary they already exist through tags as a meaning layer.

Errors, debuggers, panic, fault... These are made by the users inside the coos rather than bloating the top.

You can pause and play mods which overide the when true state. You could pause every element so it could check the 3 top parts but doesn't act on the last.

Formalize cognitive load principles so it is more than intuitive for other developers to design loload features

During a machine learning task a script may run for days and we don't want all that work to go to waste so use case recovery of complex results.

Many Programming concepts are just the same redundant concept over and over, many different terms are basically the same; instructions nested inside instructions inside instructions, and templates to make them.

Group Split enable disable

If you have a list of instructions you want them to influence space but you also want them to influence a monitor that lets you see how the whole plan is going. What if you could split off any port to a space that could control lights and values etc to give you a birds eye view of what you want. But then the space itself could be turned off so the mods arent updating them when your not looking at that dashboard. This could let you stay performant but also have a broader effect of being able to control what ports are checked or changed in large groups at once.

Should be able to simulate the future with current values, show path ghost, and live update from mod changes. Show the data, and show comparisons.

Autocomplete/Search

This can be for primitive mods, nested mods or goals returning complete solutions.

Sequential vs concurrent

Actor Model: particles(processors) work alone and send messages to other processors.

Resources

http://blog.interfacevision.com/design/design-visual-progarmming-languages-snapshots/

https://www.postscapes.com/iot-visual-programming-tools/

https://www.makerpad.co/

https://community.nocodedevs.com/c/introductions

https://www.nocode.tech/

Inventing on Principle

Age of No Code

Study Kotlin

1. Infix functions.

2. Extension functions.

3. Operator functions.

4. Tailrec functions.

5. Inline functions.

Primary and Secondary Constructors

Null”unknown” as in truth tables if any operands are unknown the result is unknown too.

Scope Functions ”setting the range of effect for a function or variable.”

Study Polymorphism

More Polymorphism

Features

If Mod will support a world of people, let’s study what features they expect. Like...

Simple, Concise, Asynchronous, Object Oriented, Functional, Ideal for Tests, Memory Safe, Exception Safe, Expressive, Interoperable, Multiplatform, Efficient, elegant, Dynamic types, Open source, metaprogramming, debugging, logging, profiling, Multiple Dispatch, Data-race Free, foreign function interface, dependency-free, Scalable

Familiar vs honest interface of the future

Mature and complete async-await for user interfaces containing event-driven code, paired with isolate-based concurrency

A programming language optimized for building user interfaces with features such as sound null safety, the spread operator for expanding collections, and collection if for customizing UI for each platform

A programming language that is easy to learn, with a familiar syntax

Safe

Memory

There are no dangling pointers and no buffer overruns. The language doesn’t even have the concept of null

Exception

There are no runtime exceptions. All exceptions have defined semantics, and they are always caught.

programs can natively call C libraries using the foreign function interface.

Mutable state is hard#

The problem with concurrency is shared mutable data. If two different threads have access to the same piece of data then they might try to update it at the same time. At best this can lead to those two threads having different versions of the data. At worst the updates can interact badly resulting in the data being overwritten with garbage. The standard way to avoid these problems is to use locks to prevent data updates from happening at the same time. This causes big performance hits and is very difficult to get right, so it causes lots of bugs.

Scalability

All Elixir code runs inside lightweight threads of execution (called processes) that are isolated and exchange information via messages:

Autotutor

Based on the finished products, you can pick a project and it will deduce a tutorial to learn how it was made without the developer having to make a tutorial as it is obvious what needs to be done by turning how it is into steps.

Godot Project

Resources

Godot language:

https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html

CoOS Design : Mod Tools

https://docs.google.com/document/d/e/2PACX-1vRqzDU7Vcx5qe0YkCrWRYHc-Qmb2wSHRSjdyYdI0RDG-yq0Av_TNBnbgYwIjOGc4lzBK5rEq8wmE8Zc/pub#h.uy5bmfu2rg1v

Purposes & Principles

Minimum Viability

Powerful: Can accomplish any project classical coding can.

Intuitive: The interface teaches how to use the interface.

Concise: Do not overwhelm the coder, Minimum Bloat or Redundancy.

Collective: Users solutions are not isolated, but shared for anyone to use without having to reimpliment.. Code can be reviewed by the community.

Forgiving: Complete History Tracking so anything can be undone/redone/changed. Files cannot be deleted, environment is sandboxed from OS’s files.

Why

Today the world runs on code, every message sent, website visited, screen swiped. Code is a language only a fraction of the world can understand. Imagine if only 1 out of every 400 people knew how to write. How many world changing ideas would’ve never seen the light of day?

If you have to hire a professional to mod your stuff then modding is not intuitive enough, because to describe what you want should be adequate instruction for modding itself.

With interface design we can visually make your instructions intuitive.

With only a few words to learn (When, Do, Logic, Process), Mod is the easiest language in the world.

Now you can focus on your goals, on solutions, on your potential and moving the world.

Strategies

Blocks

Mods

When

Do

Process

Logic

Support

List

Global Outliner

Filters

Use Cases

Truth Tables (for logic mod)

Comments

Shared Effort (library)

Line Connections

This is a stretch goal as you can always manually enter an address.

Controller

This is a stretch goal as you can always manually input the value without a controller.

Card

Style

Content

Scalability

Primitives

The work of turning blocks of code into mods. First make the above functional then develop the methods that would recreate the descent ship flight/shoot controls that we did classicaly.