I think it is important to note that types, variables, classes, methods, typeclasses are just syntactic sugar used by the compiler. As such they dont actually exist in computer code.

Ultimately what gets generated by the compiler is a sequence of instructions. There is no instruction for a variable or a method or a type.

Compiler abstractions result in no computation! I think part of why computers are so incompatible is that this is an unfortunate limitation. What matters is the data structure and fields that are shared between implementations. This is what makes code compatible.

I will make a category for incompatible computer code.

One small clarification about Hyper Hyper Space: you don't need to use MutableReference to link objects together, you need it only if you want to be able to replace the object you linked with another one later!

When the Hyper Hyper Space data layer synchronizes a space contents with other peers, it needs to validate that the received changes respect the data assumptions of the application. And yeah, anything that's mutable needs to be wrapped in a type that knows how to marshal the changes as CRDT-like operations.

The project is experimental, maybe we need more iterations before we figure out how to remove that coupling. The model is already a considerable simplification over previous ones :)

Oh, you mean translator AST to efficient SQL translator?

When you think about AST, and that it could be doing many loops over objects, creating and checking properties, and how to rewrite that into an efficient SQL query, it can sometimes be a challenge, and you'd like a system that would automatically translate your procedural query into efficient SQL declarative query.

When it comes to Infinity family / Homebase, we could do this by manually optimizing the database, and working on the DB model together, in other words, optimizing the normalization of DB model (that serves as ontology).

However, if you want to achieve this kind of thing automatically, I think, it's a challenge for AI domain, in language translation (AST to SQL), though, it would perhaps be a simpler version of translation, because the algorithms to compute the data features required to do an SQL query would be already embedded in the AST, one would just need to find good sub-queries for SQL ("structured query language" -- I think the SQL name itself implies, that we can do structured sub-queries to arrive at the final result of query).

It would be a form of ORM. ORMs track dirtiness of individual records not bulk records.

The goal is to find more efficient representations of manual code and convert it to efficient queries.

The problem with for loops (and ORMs) is that you require the data be in memory. The database is better at paging in records into memory than naively written code that loads it all at once.

Would this invention be a kind of "ORM", that supports making data mutation graph out of the box?

Essentially I want to transform code AST into an efficient query that a database can execute.

Say I was looking for books with a rating of 10/10

books = load_from_server_json('books')

good_books = []

for book in books {

If book["rating"] == 10 (

good_books.append(book)

}

}

This would be transformed into the following query

Select * from books where rating = 10

It gets more complicated when there is a graph of objects where there is manipulations to multiple fields. Like you say, you would have to have the code trace the mutations to work out how to generate an efficient query that incorporated joins.

Do you mean something along the lines, that objects are just products of mutating queries, so we want a well-defined state space?

// ORMs blur the lines a bit. What if we could silently transform one form to another

To decompose an object into queries, you'd have to have a history of mutations, a bit like git history of repository state changes.

It is obviously possible to decompose each object into queries that formed it by providing a history for each of them. Are you proposing to have histories for each object types, am I understanding it correctly? Or, are you suggesting us moving the data to a versioned data storage, that is a bit like git? How would this work in practice?

The problem with Hyperhyperspace is that I would never use it because it takes over the objects you use to store data to implement its functionality. So it takes a bad approach.

To create simple object graphs in memory you have to use a class called a MutableReference to link objects together. Feels wrong to me.

I just found the project hyper Hyper space it's an interesting project. Rather than files you have spaces and they are backed by a merkel directed acyclic graph that somehow merges seamlessly. Assuming it uses CRDTs.

They say you can build almost any app with it, forum, chat, website etc

// make the data storage layer P2P and everything else is traditional

It makes perfect sense -- most of software systems are clients of database systems.

// Can the products link in the menu be text rather than an icon? It's not very discoverable as an icon.

Oh yeah, it can. Let me do it in a couple of days, as some of the functionality of "products" (Market) isn't ready yet.

Can the products link in the menu be text rather than an icon? It's not very discoverable as an icon.

[chronological], actually, the ideas on the page /topics (when on home page, look at the top left category link, immediately to the right from the logo) are ordered in the order of recency of comments and links, so, if someone adds a comment or a link to a very old topic, it just goes back up to the top. I'll try to add random topic link, that just randomly selects some topic to look at, or just will extend the options for this page to have a random order, and more filtering options.

And, I think, ideas jump back to the top, if they get a new vote...

I am worried that older ideas won't be discovered by new users. I wonder if you could implement a link that takes you to a random idea or category. Or have a page that lists random links to ideas and categories selected at random.

Yes. Either a subset of servers hosts a subset of data (each record belongs to a server) this can be hidden from the application. This is my distributed join idea which I have a separate idea for.

Or all servers host all the data and the data is spread to everybody equally. Essentially all queries run on all servers to get to the same state. You could have a database version which is the number of queries executed so far and if a server has been offline for a time it just needs to execute queries from last seen query up to latest query, in order. That's called logical replication.

I like that. So, if I understand right, there would be nodes hosting those hub servers, and some table of server addresses available to all clients. Maybe, those servers existence can be made dynamic Maybe, a framework can be developed to convert any app into a distribution serveless app?

Hidden in this category is the idea that the easiest way to get P2P behaviour is to make the data storage layer P2P and everything else is traditional.

I created this category because skihappy raised the problem that we have where people want to reuse libraries on NPM and existing code to build distributed or P2P applications.

Without having to re write to an alien API or specification. This category is for ideas for how to retrofit existing applications to be distributed or P2P

Mindey the simplest thing that people can do to help is to backup the database with the dump URL which I have a script that runs daily to take a backup of the data. My main computer has been switched off unfortunately so I haven't been running it for the next 4 months.

I like Graph databases like Neo4j and Dgraph. I have even written a simple one that uses matrix multiplication to do Breadth first search like Graphblas.

Theres no trust of central authority. You have to trust each user's events individually.

If you see a user you dont trust, you ban them and that then ignores their transactions going forward AND historically.

Everybody has to maintain their own ban list.

It seems trust in some central authority is involved. There would be an arbitrator, and we would get judged again and cheated on. We had enough of that.

A reversal in an event sourcing system is to simply exclude an entry when reducing the data

Each change is a separate version in the history of events. You run a reduction over the history to get a final value.

To exclude a scam or return money you just exclude the bad transactions..Of course you need other users to trust your exclusion then that becomes the system of record.

Current state/value = reduce(all events so far - excluded events or excluded actors)

As long as users are trusting the same set of events the users will get the same answers. Where answer is the current value of a field in the database or the balance of someone's account in the ledger.

If I can dispute a transaction - like I didn't receive services paid for I can say that my payment was not honoured and then if I can get others to trust me, my money is returned for spending. I just need others to trust me.

With CRDTs for arbitrary text you can merge two independent changes to arbitrary text fields so no git merge process is necessary.

This article describes how fast CRDTs for arbitrary text can be https://josephg.com/blog/crdts-go-brrr/

It's a bit like Google docs synchronisation or Etherpad. Two users can modify the same document and they can be merged without issue. We can do this for every field in a record. So we could have 0oo category or idea represented by many CRDTs.

Relational links can be a layer above data storage, forming a graph. Graphs are much better to represent relational database then relational database. Relational links can be part of data set. That's how graph db works. Perhaps, there's already an ipfs graph solution like that already

Yeah, I'm thinking of this problem, and I think the right path would be --

1. Researching the database models as an optimal ontology for what is described here. (If the ontology optimizes cooperative decision-making and economic activity, then it makes sense to look for ways to scale it and make nodes decentralize it.)

2. Decentralize it.

The "how" of decentralization is, as I see -- searching for dApps that replace functionality, and providing a common UI for all those dApps, that would collectively be equivalent to the monolith application that the Infinity is.

Another way would be to build a new decentralized system from ground up, using things like gun.js, where each of users would be seeders at the same time.

// skihappy： There's ipfs.

This falls under the search for "dApps" that replace functionality. For example, IPFS is such a dApp for file storage. However, infinity as application requires the relational database as a dApp :) is there anything like that? (including schema migrations)

There's ipfs. Anyone can host ipfs node. Don't know how much work to refactor oo to use ipfs

In my additive GUIs concept I treat the GUI as a data flow system.

In an email client you have a list of folders. Clicking a folder flows emails of that folder to a email list. Clicking an email in the list flows the email into an email preview.

Perhaps widgets can be described by the relationships towards eachother and the data they flow between one another.

I've noticed from browsing Redecentralize that all the projects available are incompatible. The abstractions are all different.

It's very difficult to start and complete a project without critical mass. The result is often independent to the point of uselessness. A lot of work needs to be done and it's difficult to even build on other people's work if the work is not applicable or not finished enough.

We need some people to forge a path ahead and make things but at the same time we need to have conversations on conversations and sharing of ideas. Maybe then we can build the right abstractions or tools for eachother to use.

hey hey, 21 day challenge completed! and here's my reflection.

what happened? I tried to feel more loving energy throughout a day, when experiencing the day but also when interacting with others and environment. I took photos of body parts (10 feed photos with my hands, hair) or my environment (8 feed photos are nature and 3 were digital) and posted to a shared Instagram account - story posts as they happened and a feed post once a day.

how do I feel now? so I feel more calm, peace, trust (even in chaos). also I notice the connection between the body and the mind, i.e. when the body is tired, the mind is angry and more reactive, less observant. life feels easier too. there's hope and trust in the process. a sense of togetherness too. like, there's a deeper bond that bonds everything.

what's next? I'd like to do 21 more days challenge with some changes to the experiment. perhaps slowing down, lifelogging on paper perhaps, being more intentional with emotional shift - being more observant, transforming judgment into observation, transforming a default response to the energy of unconditional love in difficult situations (when feeling pain, tension, conflict). I'm curious to introduce a small paper notebook that fits the pocket and lifelog the moments when this transformation to observation happens, I'm curious to lifelog using saliva and a fingerprint as an invisible lifelog on paper, i.e. I know I lifelogged it, but I cannot see it, thus I don't count it (because counting sometimes sparks judgment). also, I'd like to introduce sound to the experiment. when listening to music, the body starts to dance and shift emotions instantly. thinking, what repeatable sounds that relate to the message of "universal love" would be cool to experiment in here. lastly, I'm curious to introduce a reflection moment, in the evening, before sleep to reflect how was the day like - observing, not judging, and perhaps sending some more loving energy to the universe.

to sum up, my next 21 day experiment will focus on: transforming judgment, conflict, tension into love and lifelogging those moments on a tiny notebook (finger dipped into saliva and marked on paper). tbc: sound and sleep reflection.

You can sanitise inputs to ban script tags and IMG tags to prevent exfiltration. The problem is you can't of restrict the JavaScript of the distributed app to undo the sanitisation.

If we trust the distributed app itself we can trust the fields it renders as it won't try undo the sanitisation.

I see [Ruta]'s mentioned the Snappy Widgets as desired thing on oo. ;) Without the Treenity it would be just a wishful thinking, but with Treenity (and an RFC XXXX on a good polycontext metasymbol), we could achieve this in time, and even the vision of Structured Internet Client (ultimately).

However, I think this topic is more for organizing the improvement of the current UX of "oo". So, let's add examples of possible improvements here.

Let's implement this on oo

I value the noncreative work more than creative work. Without the noncreative work we wouldn't have water, food or electronics.

At least without creatives we would still have food and water.

Creative work is easier than hard labour.

The Indihub ecosystem that Gyuri Lajos has been working on intrinsically promotes discoverability. That knowledge sharing built into everyone’s publicly shared ideas promotes scaling an idea to the network without people having to join and signup. Onboarding people is naturally a slow and time consuming process. For instance, this post and all the posts in this group are only accessible to the small number of people who have joined. If this software was ported to fission.code and made public, then anyone with Fission account can search, find and respond to this conversation thread.

One can conceive of two rough categories of work, creative work and noncreative, repetitive labor. Creative work results in the design of something new. Once created, that new artefact can be reused by others. Noncreative, repetitive labor consists of repeating a task in order to achieve some goal that is useful, but does not result in any new ideas, technologies, service or art form. Both are needed in order for present day society to operate. Creative work is valued more by our culture, reflected in patents, trade secrets and competitive advantages. Unicorns are created based on a creative new idea, while factory worker receives a small wage for their repeating the same task over and over. What is the value of new ideas compared to repetitive tasks? Perhaps intelligent robots will one day eliminate most forms of human labor, and as automation increases, we are approaching that limit. How do we rethink our system of rewards to be a fair society and not one of even greater inequality? It would seem to me that there needs to be a universal basic income that guarantees a minimum level of human wellbeing, and creatives can be rewarded, but not excessively as we have proven over and over again that the wealthy lack the emotional maturity to live within planetary boundaries. For example, the entire notion of luxury goods, that are high carbon footprint by design and designed to appeal to the consumerist elite does nothing more than reinforce inequality and degrade our ecosystems. People should be rewarded for their creativity but also for giving their time doing noncreative work to benefit others. After all, time is the most precious commodity of all, and if we use part of it to do a necessary but unfulfilling task, we deserve to be recognized for giving away a part of our life....which is what we do when we work at an unfulfilling job that just pays the bills.

I mean we don't do any sandboxing at all on the frontend and just treat the distributed app as another website.

The security to the distributed network is in the distributed app runner running in the background. That app decides what the app can do. Maybe need some console UI to approve actions that the frontend is doing.

I really appreciate your thoughts but im not following. The problem is untrusted scripts running in the browser context. All kinda identify theft and spying is possible a f not careful. The app kernel can not police what people contribute to the net. Another control mechanism is the permission system, but that's not perfect either. Who's assigning permissions and to whom? It would be helpful to large degree, but it can not weed out all bad actors.

I strongly believe it's about living in communities. Life is much easier and full of meaning and value. It's a cultural thing. Freedom is born when anyone can travel freely and light between communities, and be accepted and valued. Life by yourself, for yourself is hard, tedious and complicated

// Duh... but fun is in the diversity sometimes, just simplicity isn't enough for a happy life. I'm aware the desire that things just made sense, cognitive relax

But why do people say life is hard? Is it hard in terms of force exerted? The average man can exert 2000 calories of effort on the physical world. That's a painful exertion. Those Amazon employees are suffering shifting parcels. How can we make this life easier for those people?

They say that a job is satisfying if it offers opportunity to mastery, autonomy and purpose. I would agree with that.

I would argue that a job needs zen or getting into the zone. I have only had that when I decided on how to achieve my job.

What makes life hard? Is it working? Preparing food 3 times a day to eat, cleaning plates after every meal? Travelling to work everyday? Waking up to an alarm? Paying bills? Having to eat right to avoid getting fat? God forbid I hate exercise. I hate all these things and they make life hard for no reason.

Here's a combinatorial problem that I don't have a solution for.

You need to pick a place to live, a job and things to buy. These all depend on eachother. The shops you go to depend on where you live and how much money you have depends on your job.

I wish I could arbitrarily control websites to do searches and simple sorts for me. I need a job that is near to where I live and a place to live that is near my job. I need to search for jobs in parallel to my place to rent. You need the distance of shops to work and to home to be as small as possible. You also need good transport links.

If I decide I want to spend £650 on rent it limits my options significantly. If I say £1000 my options are wider but I would be spending a large amount of my salary.

This kind of problem needs a hill climbing algorithm that walks rent price, job salary, distance between them and shopping location distance between job and home.

So it's a multidimensional plane with many local minimums.

I remember, Elon Musk saying along the lines, that life's got great graphics, but poor plot. Perhaps, we could elaborate on the plot. I definitely got plans for that, beyond one identity. ;)

// Less complicated and simpler

Duh... but fun is in the diversity sometimes, just simplicity isn't enough for a happy life. I'm aware the desire that things just made sense, cognitive relax, but hey, all classical computers can be made from just NAND gates. I've seen a good visual, here, by Stephen Wolfram.

// Would you share your browser history to help fellow internet users? //

Conditionally - yes, and more, there are ideas floating around of sharing DOM, parsers, etc., which are ways to taking back the Internet.

Providing a search engine for the internet is outrageously expensive because the data is so large and doesn't fit in memory. We could use this approach to split up the storage requirements of doing search.

If everybody hosts a fraction of the search index then all queries go to everybody before being returned.

If there is 1000 storage nodes then every search query produces 1000 subqueries one to every storage node. Each returns what they know about.

I mean we don't do any sandboxing at all on the frontend and just treat the distributed app as another website.

The security to the distributed network is in the distributed app runner running in the background. That app decides what the app can do. Maybe need some console UI to approve actions that the frontend is doing.

A note on: dfinity.org :

The current Internet is designed to allow any protocols, at least above the TCP/IP level. Taking a subset of all possible protocols and building a network of nodes that talk in those protocols but not others, is a kind of isolationism. I'd rather look for a way to translate between protocols, that would enable to make nodes that talk in any language understand each others (on evolution of formats).

Perhaps the frontend layer is simply that - the programmer can use any React code they want and the browser does the sandboxing.

Could be hosted on localhost by the distributed server application which hosts the various distributed apps. Wouldn't be very secure because the site could make HTTP requests.

I would have a simple JSON API for talking to the distributed network and querying the database.

You could have a content security policy to ban HTTP requests.

Hmmm. Interesting. You mean localhost would do server rendering and serve just html? Even html is not safe. Something to consider. We coding an mvp, just prove of concept for now, wo security considerations. But we def need solutions. Personally, I don't think any of sandboxing schemes are totally trustworthy. There's gotta be a review process, even to assure quality of modules, besides security. I think, somewhere humans need to get involved. Making their job easier is another subject, worth discussing

Perhaps you have a UI where you create a room of people and the people in the room you can communicate arbitrarily with. So you can't create random sockets with websites and steal data. You can't open files either. Only query the distributed database.

I think it's my idea of a testnet, where you limit access to trusted users. Your code is jailed into testnet till it's reviewed. I don't see an easy and performant way to allow a vm to safely manipulate Dom. I'd like to use well known tech like react. Even pure html string is not safe, even if all state logic is separated into a func and is run in vm or webworker

Perhaps the frontend layer is simply that - the programmer can use any React code they want and the browser does the sandboxing.

Could be hosted on localhost by the distributed server application which hosts the various distributed apps. Wouldn't be very secure because the site could make HTTP requests.

I would have a simple JSON API for talking to the distributed network and querying the database.

You could have a content security policy to ban HTTP requests.

Have added a link to dfinity the internet computer which has its own runtime and language. https://dfinity.org/