Depending on exactly what you're asking for there's no reason other than inertia. For it to become useful you need a critical mass of people contributing to it.

The most obvious approach I can picture would just be taking URL links that already exist as backlinks. Why would that need a critical mass of people contributing to it?

Ah, got it, just turning existing links into backlinks, I had misunderstood you!

This is certainly possible, though there are some very real challenges!

• a bootstrap problem, if you care about links between different domains then it's always going to be incomplete, period, and it's probably going to miss the one important link you're looking for unless you're indexing most of the web. Indexing most of the web is quite expensive! So it'll be hard to get paying customers without first spending a lot of money.
• The web is mostly trash, so you'll need to put a lot of effort into filtering out the unimportant backlinks
• You'll probably never be able to index links from places like Facebook and Instagram, and it'll be very difficult to index links from places like Twitter. A large amount of activity goes on in there that you won't have access to!

In a fundamental sense, it's not possible because linking is a one-way action. I can link to your website from an HTML file hosted off this laptop - how would you ever know?

In a practical sense you can probably get close because of how much tracking there is in the real internet. I would look into Google Analytics API for that. Or you could try some heuristic like the following Google search; "http://futureofcoding.org" -site:futureofcoding.org which searches for a URL, excluding from that domain itself.

Google makes it very hard to look for links in this way because revealing too much about which links Google recognizes would greatly help spammers. I think to make anything useful you would have to do your own crawling, probably starting from an index like Common Crawl.

What sort order would you like to use for the backlinks? A page on a popular site can have hundreds of thousands of incoming links...

A worthy question and a worthwhile endeavor. Living in he Smalltalk-lite land of Ruby, my firm does have a way of sending object graphs to each other that's somewhat (and could be better) integrated into our bug tracker.

An intrinsic problem is how to merge/switch/select-part of two images. I'm sure there are good solutions just wish I knew about them back when a different group was trying to collaborate with Lisp images.

That sounds fascinating. Can you elaborate more on your approach to handle Ruby object graphs?

There are many Smalltalk systems, which could handle this differently. The one I know is Pharo. It has a class SmalltalkImage, which might look like what you are looking for, but it's really an entry point to access low-level system information. It's not an object that you could archive or send around. "The image" is not an object, it's the set of all objects. Better avoid Russel's paradox by not having the image be an element of itself!

However, you can do things that come very close to what you describe. For example, you can ask class Object for all instances of itself and its subclasses, and send those around the world. That's all objects in the system, including their classes. You might run into resource limits trying to send them from one image to another, I didn't try. If you want to play with this, I suggest Fuel (https://github.com/theseion/Fuel) as the most adequate serialization framework for large sets of objects.

Thank you for sharing your insight!

@Thanh Dinh We're basic. So far we've managed with Marshal.dump and Marshal.load. Classic Ruby dark side: quicker, easier, more seductive. Dump to file, send to somebody else. Is this unsound? Absolutely! But for a decade plus it's only occasionally been a problem: when dumps get into the 100s of MB. A rewrite some years back to use a database like a normal Rails shop failed, so I may try something different. Would have tried already if we weren't living in the end-times.

Andreas S what do you want to achieve? For me it is not clear what you want. There are many directions this could go.

Just thinking about the relationship between object and image

Well I think most Smalltalk implementations will not regard there image as an Object. The VM is probably often the element responsible for reading the image and creating the actual Objects (including Class, CompiledMethod, Context, etc) and continue execution where it left of when being saved.

That said, it would definitely be possible to see it as an Object. A Smalltalk implementation could even run (simulate?) the environment inside a supplied image. Do remember that things like garbage collection are often (must often) be done by the VM. So simulation is not trivial and might require quite a few extra features in the ‘receiving’ Smalltalk image. HTH

I'm normally of the opinion that results are what matter, and it's OK if something is made of sellotape and cardboard if it's making someone's life better... but in this case, no, it feels too ridiculous. I guess this is my limit, and I'm definitely on the Jonathan Blow side of the argument.

the thin/fat client pendulum is changing direction again

I don't suffer from this, but my wife's laptop is frequently brought to a halt by misbehaving tabs. The operating system browser really should do something about hot running processes pages.

the thin/fat client pendulum is changing direction againThere's a bit of a split going on I think. The "cool kids" zeitgeist seems to be going the other direction (e.g. Ink&Switch), both for privacy and performance reasons. I recently moved house and go better internet (70mbps) and tried out Stadia and Xbox Game Pass Ultimate and the performance still isn't there IMO, the ping is very noticeable. Maybe once cloud compute infrastructure is common in every town, like a post office. If you live next to an AWS datacentre, then yeah I'm sure the calculus is very different.

My take: On a Mac? Just use Safari.

Tried it. 😱

I love it. The M1 has obliterated any need I would have for it in my day to day, however in my data science work I have an insatiable appetite for more power in the browser. I can envision use cases where I'd love to have browser tabs with 1TB of RAM running sims and then just duplicate the tab and change some params and run another sim. In my work on Ohayo and Our World in Data we are not even close to .1% of where data science could be in the browser. A big limitation is the specs of client machines. This could in theory make those caps adjustable and so I'm very long term bullish on it, if that's one of the directions they support

A common pushback I get on this is "why not build a native app". The browser experience is far superior to native apps, IMO. Instant sharing, 10's of billions of devices ready to go, rapid development, etc. So I think all of data science long term will move to the browser tab

Tableau, Excel, etc, all of those native apps will be left in the dust (that's a bet, and I could be wrong, but that seems to me where its going)

Of course if you have to stream a browser, you might as well make one native app that runs on Linux and stream that (Stadia model). I guess it speaks to web development being a preferred stack, or the only stack, a lot of developers know, especially in the startup world.

isnt't ssh "streaming a datacenter"? 😛

and a vpn "streaming a network", a remote desktop is streaming a computer, a web server request is streaming computation/data

Which leads to an interesting FoC conversation, which is if we did move wholesale to dumb clients that render streaming video, what kind of development environment would be ideal for that

Mariano Guerra they are

I think the difference is accessible GUI apps (yes I know Remote Desktop exists)

I would reframe it as computation that's independent of where it's taking place

ship the computation near the data or to the computer with the GPU or to the one with more ram and stream back the result

Here I'm talking about a specific implementation, not a general concept

migrate this browser tab somewhere else so it can keep running, or it frees some resources on the machine it was running before

A remote computer that is just in time provisioned (not owned by the user) renders and simulates an entire application, encodes video and sends it to a client that plays video and sends input to the remote computer

do you mean accessible GUIs as in "screen reader"?

🍿 (I have 100KB/s download — oh, Canada...)

I used to use X-Windows over dialup 30 years ago, so I assume that same technology would still work (but much better) these days. But I don't understand how this is a good idea, since CPU and memory are very cheap and I currently have 73 tabs open without a problem. Maybe we should instead look at why a web email client requires 250M of RAM, when I recall an 8M machine was considered pretty high-end and could run a more full-featured email client with only a fraction of that memory.

And, even then, 8M was considered staggering inefficient by those who were used to Xerox Alto's with <=512k of RAM.

Yes, we're using more memory for higher-resolution screens with more colours, but that only accounts for a small part of the difference.

A big part of the problem is, IMO, that browsers like Chrome are written in an unsafe programming language, and that they mitigate against this risk with a heavy-weight process model.

The examples mightyapp gives are using apps like figma that take advantage of the extra ram and a good GPU to do things faster on a powerful computer from any other computer, I don't think the main use case is checking your gmail faster or having many tabs open (I could be wrong).

as Breck Yunits said, as more data intensive applications move to the browser, the same thing will happen with them as with figma, you will be able to run them on your machine for small to middle datasets and migrate them somewhere else when the dataset is huge and/or you want to let it run overnight training a neural net or something.

I think the ideal for me would be that where you run it is a choice, is transparent (you can't tell where is running except for the performance benefits) and you can migrate things while they run. Thinking which programming models would help achieving that by removing the "browser" part is an interesting thought experiment

The current context makes the mightyapp people think that this is a solution to a problem people have (and unlike many others, they talk to users), they have to start somewhere, I've seen them mention "an always on computer", this is just the first useful step along a path, if they manage to make each step profitable they may dictate the future of "locationless computing" while others laugh about how dumb it is.

I wonder how much Mighty does (if anything) to compensate for the round trip latency... With their example of Figma, I assume they get a lot of it "for free" since Figma is already set up for multiplayer editing... I wonder how it performs in other apps that are not already designed for latency.

J. Ryan Stinnett I noticed that they are filtering their initial users for people in SF and NYC (close to their regions). So one way they seem to compensate for latency now is just to allow people phyiscally near a mighty DC

Yeah I doubt they do much beyond require low latency network and that you're close to their regions. It's possible they do something with input buffering or prediction on the browser or even OS level, but I doubt it

Correct me if I'm wrong, but I think they can get a fair amount of half-decent prediction simply by virtue of the way video codecs work. Unlike a game (thinking of Stadia here), where you have a lot of full screen motion with complex transformations, a browser is mostly static images (free to predict), occasional scrolling (typically a large chunk of the screen moving the same direction and distance, trivial to predict), and infrequent whole-screen changes when loading a new frame (prediction is outside the scope of the codec). Modern codecs like h264/h265 handle the first two with aplomb.

That's a fair point, but I do bet the most interesting use cases would be the ones with lots of moving visuals (I'm thinking simulations)

yeah, it's fair, but Mighty is targeting high compute applications that might not care about latency, and probably don't care about latency as much as your average game, but definitely care about latency more than your average web application

like figma

FORTH and APL are both quite integrated into an environment and a certain way of working.

Now that you mention those, Mathematica comes to mind

Unix/Bash, Emacs(?)

What's your definition of "system"? UNIX is sort-of the programming system for C. Does Visicalc or Excel count? How about web browsers? I think FOAM would count.

Development happens "inside" the system, you (almost) never leave it to complete a task

Erlang systems have hot code patching too

Dtrace and some aspect oriented things as well

yes, but the development doesn't happen inside the running system and using hot code reloading by default

I wouldn't recommend it but maybe OSGI + jvm also counts?

for the same reason no, java developers don't code inside the jvm where the code runs, the ide doesn't run there either

Processing?

Many Java IDE's are written in Java (Eclipse, NetBeans, BlueJ, etc.).

yes, but you don't work inside the running system all the time, manipulating live objects, changing them directly, loading new, the IDE being only some other objects in the same system, almost never restarted

full introspection, interacting with live instances, defining new ones

if it was the case you would be able to modify eclipse from within itself, without restarting it or having to run any external tool to compile the changes, the concept of compiling and restarting to get the new thing is a good filter of non programming systems I think

https://lively-kernel.org/

https://squeak.org/

https://newspeaklanguage.org/

on the game side Dreams, Minecraft, Roblox

https://gtoolkit.com/

Tudor Girba your input would be useful 🙂

https://selflanguage.org/

I'll put the "!" where @Deech's "?" is as regards emacs, it's definitely one of the most alive systems. That said, I feel like it's covered by Mariano Guerra's initial mention of Lisp Machines.

Mariano Guerra Both Squeak and GToolkit are direct descendants of Smalltalk-80. There are a few more, e.g. the minimalist Cuis (https://cuis-smalltalk.org/). Self, Lively Kernel, and Newspeak have clear Smalltalk inspirations, but are different in important ways.

A good resource to find other, often more specialized, systems is https://github.com/toplap/awesome-livecoding

Jupyter notebooks with Kubeflow has both editor and runtime

If you're talking about game/VR stuff, Facebook Horizon, Anyland and RecRoom count

I'm actually not sure if Roblox should count if you're talking about a live environment. Roblox requires a separate install (Roblox Studio) for development

so it feels a lot more like a traditional game engine in that sense. It's a subtle difference but a regular user can't find studio through normal gameplay, and you can only create in desktop environments (PC and Mac), while many of Roblox's users are on mobile or console

I think there is one distinction that is often neglected when discussion programming systems or live coding environments: the degree to which the development tools are part of the system. Smalltalk systems (except for GNU Smalltalk) and the Lisp machines have rich tools as part of the system, making them accessible to modification and extension from the inside. Emacs is almost the dual, putting the tool aspect first. Most other Lisps rely on external tooling, while not excluding the possibility of adding it to the inside (e.g. CLIM for Common Lisp, DrRacket for Racket).

There is also Scratch (and friends like Snap!, etc.).

GT seems to be different things to different people, depending on how long one looks at it 🙂. But, the idea of moldable development is really that there is no single perspective about anything in a software system. Code and objects all should invite different perspectives, and most of those perspectives will be for reading only, without necessarily providing any editing capabilities. And, when we bring it to its natural conclusion, we do end up with highly specific experiences for each system parts.

I'm a firm believer that the future of visual programming will grow from spreadsheet land (http://worrydream.com/refs/Kay%20-%20Computer%20Software%20-%20SciAm.pdf)

so many sheet based tools coming out (google sheets is the gorilla but also airtable, http://rows.com, smartsheet, etc)

the MS research group is crushing it with things like https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/

Tech moves in sin waves and I think we're back on a steep upward trend in spreadsheets