I mean, the project that birthed Electron — the Atom text editor — was designed to be modified by the user in a bunch of ways, depending on their technical ability and interest:

• download plugins to add readymade behaviour
• make new plugins by coding against the high-level APIs, or by directly manipulating the DOM
• add custom keyboard shortcuts
• add custom scripts (that can be run by shortcuts, or on events)
• add custom CSS

This might not seem so special, but today, even after they worked to drastically narrow the extent to which you can mess with Atom's rendering (for the sake of perf), it's still wildly more customizable than other Electron-based apps, including VS Code.

That's cool to hear. More specifically, what I'm referring to (and these things tend to be hard to describe precisely) is an app where its code is available for modification within the running app while it's still running. It doesn't sound like you described Atom as working that way.

Light Table was built that way

... not as concrete as your examples ...

I argue that programming becomes much easier when synchrony is expunged --> FoC, distributed, visual, etc, etc.

more discussion

I would like HTTPS://webcode.run to be the running, but it's true ambitions are not obvious yet, but the point is a federated inside-out compute platform. Bring the compute to the data type thing using the portability of the web.

Does Ethereum qualify?

There was also a cool demo posted here about a year ago that was a programming model for the future era of computers that are like a swarm/grains of sand. I thought it was called something like Horde Computing but I can't find it now 😕

ethereum runs the same computation in many nodes for security/consistency, I'm looking for languages that make it easy to distribute and scale computation

Ethereum: Enabling massively synchronous computing!

Mech!

My demo from a couple weeks ago showed off some features, but my talk at HYTRADBOI will show off more.

💬 #two-minute-week@2022-03-17T00:25:00.478Z

Thank you Mariano Guerra for tapping into that context and bringing up the question. @William Taysom the blockchain people are actually coming around, acknowledging the poor idea of 1 global blockchain/sync computer for all things for all human beings. In recent years more and more sharding solutions are implemented you can see that with polkadots parachain model, Cosmos, RChain , Cardano, even in the Ethereum Ecosystem there are are many "satelite" Efforts like Gnosis Chain. These Efforts point not only to technical difficulties but in my opinion its a cultural thing. Human beings are not like a global bee hive cluster, or bork cluster for that matter. We have distinct cultural and local history backgrounds. We are still looking for ways to express this with technology and its accompanying patterns of behaviour ( what seymour papert called computing cultures)

Another space/community that I have been part of for some time is the sensemaking/liminalweb community. There are people in that community that think web3/crypto/blockchain culture is interesting because it gives a chance for a cultural - technological movement to be self-aware of itself. Think about it one could say: why not AI? The AI or AGI narrative for that matter promises also the ultimate salvation: technology which fulfills whatever wishes you come up with. While web3 maybe promises "better" money and thus better coordination. The Role and perspective of a human being is quite different in them (IMHO). I try to be on #teamhuman 😅

One could also ponder how conceptually different unison and t2 tile are... Personally I would see Ethereum right in the middle between them. While I see unison still very much rooted in organisational patterns like: cloud - service provider etc.. t2 has quite another language and field of experimentation. And Ethereum hm yes there is a lot of "money" and "investing" buzz going around there. But there are also the projects that care and experiment with different models of governance, from the DAO context for example. These are the projects that are interesting for me. we discussed this a bit here: https://futureofcoding.slack.com/archives/C5U3SEW6A/p1649256183659749

One more story... I once tried to point out to the unison people that at the ethereum dev0 conference in berlin 2015 there was a talk/proposal to create a dev environment not unlike to what they have build now. But they weren't really interested in looking for connections to that space. Of course a projects needs supporters to supports its identity. But remember when I talked about self-awareness? Some DAO and other projects in the web3 space now realize that: There is a significant importance on how you build and its not so much important what actually you build. Eventually these two form a living relationship, but it is the awareness of that relationship that can change our(humans) relationship to technology. I'm curious how, if and when eventually all these communities will touch each other eventually.

Apologies for just dropping yet another perspective and self-promo in here without reference to what's already been written, but... 😄

... my own project (the http://Object.Network ) has two core attributes: Declarativeness and Decentralisation which I think correspond to these two elements in the OP (FoC and Distributed). Both capital-"D"s derive from a single deeper concept: the Big Inversion 😮

That basically entails turning the current, pervasive "code-on-the-outside-data-on-the-inside" programming model inside out: thus "data-on-the-outside-code-on-the-inside". This means data is freed from the traps of Imperative, Service-Oriented architectures.

And the opposite of an Imperative, Service architecture? A Declarative, Decentralised architecture, of course!

In this programming model, you see and interact with data first - before functions, like in a spreadsheet; it has "internal behaviour" (Declarative). Imperative is "how over what"; Declarative is "what over how" - the detailed mechanisms of behaviour are hidden behind a declaration - i.e., more data - of the required behaviour. It's basically like a virtual world of data - if you enter Minecraft, you see stuff before you see its behaviour - things are internally-animated.

In the Object Network, all our stuff is sewn together into a kind of Metaverse, using links between data chunks. Data is held locally (Decentralised), so that we have full control over it, instead of imperative data-wrapping, techie programs and Big Tech services.

decorators in python? https://peps.python.org/pep-0318/

Python decorators. I think Rust calls them annotations as well. Elixir via Erlang, apparently. Nim. I'm less sure about C# but I'd bet 5$ they have something like that too. They're pretty common these days.

Stage 2 proposal on js https://github.com/tc39/proposal-decorators

they already exist in typescript

And now to torpedo this thread — can someone explain to me how these are meaningfully different from lisp macros?

Or, on the other hand, higher order functions? Are decorators just... sort of like a HOF or macro, but applied in a specific way, and thus it's useful to introduce a new term for them to help us talk about this particular usage? Or are they truly a new and different and fully general sort of thing?

Well, to the extent you can even consider them as a group, considering the very wide variety in semantics, they're pretty sharply limited (by design) relative to proper macros. The others seem to be more complicated, but Python decorators are literally sugar for wrapping the advisor annotated item in a function call. I think Rust annotations are just tags that can be processed by some other build-time code.

Ivan Reese Python decorators are just syntactic sugar for a particular use case of higher-order function. But since readability is an important criterion for Python programmers, and since Python does not have anything like Lisp macros, syntactic sugar can make a big difference.

I'm more interested in the idea of an abstraction around slots (instance variable name and value) that manages meta data and computation related to it than a particular feature of this general area (such as decorators). Yes, we can implement decorators with macros etc, but that's just one small feature related to this area.

clojure supports metadata for any datastructure https://clojuredocs.org/clojure.core/with-meta

Steve Dekorte Pharo Smalltalk has something like that, see https://hal.inria.fr/hal-00641716/document. Slots can be defined by classes, making them almost objects themselves. I have used this myself only once, to trace and record slot accesses. It’s surprisingly straightforward to use.

Rubyist checking in. At some point (probably a decade or two ago), the method definition construct was made to return the method name so that you can easily write your own decorators. This means that when you write synchronize memoize def calculate(something); ...; end, the interpreter:

• defines the calculate method,
• sends the symbol :calculate to the memoize class method, which will presumably define a new version of calculate and return :calculate, so that the interpreter
• again sends the symbol :calculate to the synchronize class method, which will presumably wrap calculate again.

In Ruby, public, protected, and private annotations are all methods that one could (and should not) override.