I'll be sure to post back here, then!

My central curiosity: I'd expect documentation for a library to be nearly isomorphic (using the term very loosely) to the code at that abstraction layer. Entries for exported functions; subentries documenting arguments; etc.

Product documentation is still likely to be coupled, but more loosely. Kind of a Conway's Law for interfaces.

There are a bunch of systems that use the cells-with-formulas/relationships model behind the scenes. Here are two from the Clojure world:

• https://www.maria.cloud by Jack Rusher et al.
• https://github.com/hoplon/javelin (used in the https://hoplon.io web framework)

(Just realizing I glossed over part of your request — these aren't expression languages! Still, hope they're somehow helpful.)

We use a spreadsheet like dataflow model in Maria, and it's definitely for authoring more than 14px high blocks. I'm still not sure it's what you want, but if you tell me a bit more I'll try to put you on the right path.

It may be a stretch, but depending on your use case Dhall might be interesting. It's basically a total functional language for generating JSON. https://github.com/dhall-lang/dhall-lang I assume it's amenable to static analysis, but I don't know what kinds are available off the shelf.

thanks for the links folks! the intention would be to use this language as a way for users of a low-code app builder tool to quickly author small snippets for the code part of the low-code. still just exploring, but i'm interested in picking a language that has the right bones for this kind of task so that the platform can handle at least some of the accidental complexity around managing n+1s or pushing predicates down to the database or what have you. so far the thing that seems most appealing would be https://github.com/Agoric/Jessie i think for developer familiarity and dropping a lot of the dynamism of JS to get back to something i have a hope in hell of analyzing

The main problem has to do with compatibility with other libraries that use the same prototype methods. Otherwise, I think you’re good to go. Also check out Sugar.js https://sugarjs.com/

the page about their philosophy with regard to extensions and how they go about it is actually exactly the kind of in-depth discussion i was looking for—thank you!

im trying to implement new semantics for collections but I want to retain literal syntax because i’m a big baby about readability

Oh, I do the same thing. I just check for existing properties with the same name before patching. I'm not writing a library, so who gives a shit!

Math.TAU forever!

Just don't the like that customer support software I was using. They decided to monkey patch arrays in an update and completely destroyed my production app. Quite the nightmare to debug 😭

Garth Goldwater you have come to the wrong place to be talked off this ledge. "Here, have a parachute or, better yet, this pair of wings."

everyone in this thread should be ashamed of what they’ve enabled

lol, I like it!

me too—my crimes will only get worse from here. a chicken in every pot. a render for every datatype. an edit for every object. chaos reigns!

You can do whatever you want of course. As for me though, why I don't monkey patch

• don't find out later a function was added with the same name and now in order to use it I have to refactor all my code
• don't want to mis-lead others into thinking this is a standard function. This comes up a lot since I write tutorials and in particular one of the first/original tutorials on one of the topics I write about monkey patched things in and confused learners for many years. For at least 8 years people would ask on S.O. why their code wasn't working only to have to be told what they thought was part of the official API was monkey patched by their tutorial. Fortunately those tutorials are no longer online but the legacy lingers since the examples have been copied forever
• because while I might not care about other people's code or never worry my code might become a library I'll get use to this pattern and then find it frustrating when there's a case I can't use it. Prefer just not to go down this path in the fist place.
• and finally, because I don't get the benefit at all. Why is someArray.render(msg) better than renderArray(someArray, msg) so zero pluses (for me), multiple negatives = I choose not to do it.

For point 4, you then need a way to get renderArray into every scope where you want to use it. If you're trying to minimize namespace pollution, that's extra friction — and it's arguable the friction, as minor as it is, is worse than the downsides of patching. (Not even touching the OO vs FP -ness of this suggestion, haha)

i’m looking at this as me being spoiled more than me being sensible—i could reframe the original question as, “if i design this system to work exclusively with my aesthetic sensibilities of what i’d like js/html/css to work like, how expensive will it get and what currencies will i be paying with”.

i’m not like super concerned with questions about relative merit—for the renderArray example, i’d like to not have to repeat type information, and ivan’s point about namespaces also lines up with my preferences—i don’t want the cognitive load of remembering what i’ve imported where (similarly, i don’t want the cognitive load of remembering to assign new identifiers by calling a function and passing an array in every time i want to do something with it). i don’t think i’d recommend other people do this.

it’s more of an “i’m thinking about making my own bottle rockets in my backyard, launching them at my face, and using a trash can lid to block them like i’m a dungeons and dragons character. what should i be worried about in terms of, eg, eye protection”

Gregg's personal reason #3 carries a lot of resonance with me. I have that thought too.

But I inevitably end up standing on the other side of that line in the sand. I'm almost always in the "designing languages / frameworks" mentality, and I like to play with different kinds of syntax or call signatures or conventions just to learn more about the pain and pleasure of any given variation from the norm. It's nice to be able to do that a little bit while still benefitting from all the infrastructure of JS and in the context of an actual product/serious project, rather than (say) having to write my own language and then figure out how to have an ecosystem around it and then find some sort of toy example project to build in it.

This is the sort of "play" I was https://futureofcoding.slack.com/archives/C5U3SEW6A/p1597465108036100?thread_ts=1597436373.033600&cid=C5U3SEW6A in that other thread.

Might be http://userland.org/ ?

Yes that's the one! Thanks!

I missed this one... Very interesting! I like how it mix outputs from several "realms". I also like the way you see the intermediate results of a shell pipe chain. Thanks for sharing!

I absolutely adore Userland although I haven't had the chance to try it yet. It's so immediately understandable to me, maybe because it's sufficiently close to the status quo, although it's also such a real demo and design. It just rings true and you are certain it would work and be useful. I think this is because the creator is making it for their own needs.

Compared this to https://www.mercuryos.com/ which I find very difficult to understand with it's avalanche of Concepts and Ideas. It just doesn't feel real. It's the software equivalent of photos a minimalist flat where you can just sit at an empty desk with a coffee and a macbook and a view of the fjords. It's an attractive idea but then you think - where do you keep all your life crap?

Chris Knott I like both. Userland is a functional prototype, Mercury is a conceptual design. As strategies for exploring new spaces and communicating what was learned, they make different tradeoffs in terms of concreteness, broadness etc. I don't think you can make a fair comparison between the two without acknowldging that fundamental difference.

You want pointers rather than references. You’d then change what’s at the pointer’s location, while leaving the pointer as is.

In C++ you write *this = newObject;.

In JS, can you just delete all existing fields on this and update with your new object? It's probably possible to do similar things in Python, as long as your remember to update the prototype, class, etc.

https://gbracha.blogspot.com/2009/07/miracle-of-become.html

You thinking something like Array.prototype.map but that mutates the array rather than returning a new array?

Or are you thinking something like... arr[x] = fn(arr[x]), but where the function somehow knows about the array so that you can just call it like fn(arr[x]) and it takes care of updating the array?

Or are you basically asking for become:? Your domain / hyperlink example makes it seem like that's what you're after, and in this case the fact that arrays are involved is irrelevant.

Let me know what you want the calling context to look like, and I'll see if I have anything in one of my dustier tomes.

Ivan Reese it’s more like become , i think.

specifically i’m experimenting with going all out on the idea of message networks (making up this vocab as i go along)—so instead of map or cata, i’m seeing if i can do stuff like have arrays “broadcast” messages to their children recursively. something like:

Array.prototype.broadcast = function(message) { this.map(i => i.broadcast? i.broadcast(message) : i[message]``()``) }

so ideally the objects in an array would update themselves in-place without having to reassign at the array-level/parent-level abstraction, if that makes sense

turns out my mental model of references as “pointers with extras” was wrong lmao—thank you Chris Granger

Mariano Guerra this is gold i had never heard of become before thank you

sorry the formatting is screwy i’m on my phone

Thanks Mariano Guerra. I came here to mention become:. Works well for state machines.

Yes! I built a character animation tool that used the same kind of capture, but with direct manipulation of the graphics — you'd perform the animation like a puppet show, and then clean up the curves after the fact. (Similar to http://worrydream.com/StopDrawingDeadFish/, but feeding your puppet performance + any sound you made into a timeline editor)

This idea of a "looper pedal"-like UI for rapidly entering data (even, or especially, rough-draft data) is really exciting to me.

Another take on it is https://iorama.studio, which has been shared here a few times. Let me know if you know of any others.

Dreams has similar functionality in it's audio editor as well https://youtu.be/E3BPsKb8p6I?t=1033

Dreams has so much cool shit that's buried in 1 hour + tutorial videos that are mostly navigating menus and talking

The Dreams reference is useful though

https://docs.indreams.me/en/help/getting-started/edit-mode-guide

Ivan Reese Some of my personal art tools work in a similar way, where I draw curves that get used in various ways (to feed the manufacture of shapes, to control easing of animations, &c). I'll get around to making some videos about these things one day.

Fun. I could see that being combined with hypercard's idea of levels -

• level 1, just show a form or whatever the user typically sees
• show information moving around, combining to become a payload
• see as data goes through the browser to become a network http request, headers etc
• see as data lands on the server, moves through ingress and gateways, to land in a db and back out through API - a combined view of all inbounds and outbounds
• see the performance load everywhere, I/O, bottlenecks

One of the things I think the best programmers are able to do is either find interest in or make themselves interested in the problem at hand through various framing techniques or other changes to the problem. Because interest increase attention, energy and the potential for flow state, your output on an interesting project is vastly improved.

And they do that despite programming being riddled with things that sap interest, attention, energy, and potential — things that we can and should remove or replace :)

Professional programmers (who also tend to make programming languages and tools), have a fixation with making programming feel like serious work

I was working on an end-user programming language in a "social VR app" (game) that was supposed to be a fun creative experience and there was debate as to whether it should be fun or joyful (some high level goals explicitly stated it shouldn't be...)

The education market has this exact same dilemma — some people (especially the ones paying for it) tend to have an aversion to the idea of "play", which, of course, runs entirely counter to all the research about how people think and learn and socialize productively and fulfill themselves and become actualized and have breakthroughs.

Actually, this was brought up before but there is a strong argument that education does not have to be fun.

https://www.youtube.com/watch?v=g1ib43q3uXQ#46m17s

Here are a couple of dudes eating breakfast and reading/watching the news on their pocket computers/dynapads/iPads in 2001: A Space Odyssey, made in 1968. (The film's technology consultants https://ethw.org/First-Hand:Bell_Labs_and_2001:_A_Space_Odyssey to get the details of a screen-based future right.)

BTW, most Meaningness readers are interested in his long-running "Meta-Rationality" project, but FoC members might be amused to learn that in a former life he co-authored the paredit-like structural editing features in Zmacs (the Lisp Machine's editor).

Interesting that the couple of dudes are watching the same thing. I wonder if people hadn't yet considered the possibility of on-demand abundance.

Stuff goes way back. Here's effectively a cell phone from 1931

And the smartphone from 1874

https://entertainment.theonion.com/long-lost-jules-verne-short-story-the-camera-phone-foun-1819567554

There's also the first fax machine from 1843. I forgot what documentary I saw where they actually showed one working.

https://www.thoughtco.com/history-of-the-fax-machine-1991379

This should be pinned. I think it’s possible to pin messages in slack right?

I took the liberty of pinning all the messages

center on your thoughts should go inIvan Reese is this a typo?

Thanks Ope. Good idea.

I don't believe that's a typo, Nick Smith. Here's a rephrasing:

Posts that might include a link as supporting material, but that are mostly based on your own thoughts or questions, should go in #thinking-together.

Ah, I see. Another parsing error of mine. The extra comma helps.

Many games use Unreal Blueprints extensively too.....

Hollow Knight was my favourite game of 2018 (tied with Celeste), so this is really charming to see.

Made with Playmaker https://assetstore.unity.com/packages/tools/visual-scripting/playmaker-368

I had no idea. Such a good game.

loved seeing that parallax view in this article, really amazing work for a great game. looking forward to investigating playmaker!

Try using reddit, or slack, on mobile web. You are constantly badgered to install the app. Which makes sense for surveilance capitalism, because mobile apps can spy on you far more effectively than web pages can. App installation is generally easier and lower friction on mobile as well.

Reddit's web interface on mobile is so bad after the last redesign that I've started to think they're intentionally ruining it to get people to install the app. 😕

Would folks fancy a Q&A with Alan? Like me he lives in London, I could maybe set up a livestream. Warning: takes him a minimum 25 minutes to answer a single question.

@hamish todd A Q&A would be awesome!

(I think this warrants a separate thread — it's no longer about the twitter account in question)

As someone who’s watched 3/5 of the talks you mentioned, I really appreciate how you’ve ordered them and tied them together.

Haha it’s a rough ordering. It’s not even chronological but I think it’s a good order for watching 🙂