Not really. Programming is very linear in all forms I know¹.

1. There's a start point. UNLWS has none.

2. There's a mandatory canonical traversal order of the text (the compiled instruction pointer, at base). UNLWS has none.

3. Structurally — i.e. even ignoring execution — it's mainly a tree, not a graph (parent class > child class > instance > function, e.g.). There are some parts that are directed graphs, like mix-ins and some RDBs. True multigraph structure is fairly rare. UNLWS is pervasively a fully connected multigraph with some directed edges (like irrealis).

…

Programming is, however, similar to UNLWS in that both are isomorphic to predicate calculus (e.g. functions, like UNLWS glyphs, are n-ary predicates). I think that's what you're probably catching on.

It is an important feature… but I think you're missing the more essential nature of non-linearity.

(It took me several years to grasp enough to start making UNLWS, so don't feel too chastised. It's a very difficult concept. :p)

I believe that complex circuits (as in wiring) and flowcharts do have the non-linear nature, though. Perhaps it'd help to think of those?

¹ I don't know functional programming or constraint satisfaction systems. It's possible those are different.

The actor model is non-linear. Reading the code gives you almost no clue on the order of execution.

That seems to me to be more like multithreaded linear than non-linear per se.

There are multiple linear components, and it's not obvious how they emergently interact — but they don't quite have the interconnectedness and non-directedness properties.

(I think that it's impossible for anything that's time-embedded to really be non-linear, short of time travel, since time is so fundamentally a directed linear vector.)

It's certainly a related concept, and these are aspects of non-linearity, but to my view it lacks some essential Buddha-nature of the full thing.

Especially Befunge. Here's fizzbuzz[0].

It's a stack based language where each character pushes something onto the stack or operates on the stack. The code pointer starts in the top left going to the right. But when it hits things that look like arrows (<, v, >, ^), the code pointer turns in that direction and starts executing that way. There is also the ? command which sends the pointer in a random direction, _ and | which pop a value and send the pointer left/right or up/down if its true, and # which makes the pointer trampoline over and skip the following cell in whatever direction the pointer is moving.

https://raw.githubusercontent.com/kagof/VSCode-Befunge/maste...

Maybe a pure logical programming language such as MiniKanren can be seen as non-linear? There you just read in all the rules you defined and (I think) it does not matter in which order you try to match the rules when you query the system.

> Every glyph includes a number of binding points, one for each of its arguments, the semantic roles involved in its meaning. For instance, the glyph glossed as eat has two binding points—one for the thing consumed and one for the consumer. The glyph glossed as (be) fish has only one, the fish. Often we give glosses more like “X eat Y”, so as to give names for the binding points (X is eater, Y is eaten).

Seems so ... even in logic programming we have logic glyphs. Maths is full of glyphs with connectors, especially the integral sign.

<bank-glyph>->50<money-glyph> is sorta analogous to bank->withdraw(50) ... (HN seems to be removing emojis)

This makes sense ... is this how chinese words operate ? Its logical and it makes sense why early languages were logogram based. In normal languages like english it seems the "connection" points are separate and split into separate words.

Has anyone done research on commonly used words in code ?

UNLWS can definitely be described as being based on "predicate calculus" (as in formal logic). I personally have never felt it to be a very apt or helpful description — I think of it more in terms of Lakoff-style "frames". However, every glyph in UNLWS, including the all-pervasive minimal glyph (a dot, which is implicitly in any line), is a predicate.

FWIW, no this isn't how Chinese works — and it isn't ideographic. Hanzi (& Japanese kanji) have both semantic and rhyme hinting components, and aside from a few words that are nearly minimal in their use of radicals (the components), are generally vastly underspecified to get the meaning of the grapheme unless you know it.