You are viewing archived messages.
Go here to search the history.

Konrad Hinsen 2023-10-09 10:19:39

A blog post about my recent adventure into improving my Mastodon experience, do-it-yourself style:

blog.khinsen.net/posts/2023/10/09/deconstructing-the-mastodon-client

Not quite end-user programming, definitely not professional software development, but something in between.

📝 Deconstructing the Mastodon client

Ever since I joined Twitter in 2011, and then moved to Mastodon in 2022, I have been unhappy with the timeline view proposed by both of these communication platforms as their main interface. Now I have finally done something about it: I wrote my own Masto...

Matt Wynne 2023-10-09 21:10:49

I wrote a piece about feminism, and what patriarchy means for "agile transformations": mattwynne.net/feminism

📝 Feminism — Matt Wynne

In this post I want to talk about feminism: why I have personally embraced it, why I encourage you to, and — since you’re probably readin...

Jack Rusher 2023-10-10 07:19:15

There’s a through line here to the origins of industrial employment (e.g. Taylorism) and management culture, both of which stem directly from military models of social organization.

Eli Mellen 2023-10-10 12:24:10

It is only tangentially related, but I think you'll find this interesting, @Matt Wynne

Geoff 2023-10-10 07:23:52

Hello all,

Very proud to introduce ⚡️Hyperlayer - Debug Rails apps 10x faster:

github.com/geoffw8/hyperlayer

☝ Code and demo video in the repo.

It works by creating a visualisation layer which combines application flow, state and the code itself. It utilises Tracepoint and AST under the hood to build the visualisation. This visualisation means you can cut out a significant portion of the steps we have to go through to "manually" debug an issue, leading to the timesave.

I would absolutely welcome any feedback. I think it could be a big deal!

I'm really excited about being able to share this with the world.

Marcelle Rusu (they/them) 2023-10-10 14:00:48

Started working on a prolog backend for coil.

Here's an example of compiling a coil program to prolog & exploring the codebase via prolog repl.

This is early but the hope is to have an easily explorable codebase, to really treat the codebase as a database.

Ambition for this is

  • Allow users of coil to write their own rules in prolog to ensure things about the program
  • Make writing a type checker easier for me
  • Make writing tooling for coil easier
Marcelle Rusu (they/them) 2023-10-11 14:21:06

Talking to others I realized I'm giving the wrong idea by talking about types here.

I'm not very interested in building a full fledged type system, but a very powerful constraint/linter system that end users can easily extend.

Mariano Guerra 2023-10-11 15:41:20

Conversational User Interface Prototype

  • Select & pre-configure interactive UI components by asking an LLM in natural language

  • Group them in sessions

  • Reuse workflows by storing sessions as templates

youtube.com/watch?v=nzGesIIToU4

George Svarovsky 2023-10-12 09:08:38

m-ld is a component for sharing live information peer-to-peer. (Lots of materials at the link, and click the big green button to find code playgrounds.)

It's intended to allow programs to be written "local-first", having a reactive local model that is concurrently editable from multiple remote locations, with a guarantee of eventual consistency. So, you more-or-less write your code as if the data is 100% local, embedding m-ld as a library, and magically find that other remote participants can read and write the data too (subject to security!).

There are two main use-cases we're targeting – client apps, like office tools, supporting collaborative editing (GDocs-style); and microservices sharing information like configuration or master data. In both cases, you don't need a (extra) server for the data (though you do need a way to pass messages, for example a pubsub).

I've been working on this for a while so there's a million things I could ramble on about, but I'm curious to know if the above pricks up anyone's ears. Do those use-cases sound, well, useful? Does my description make you want to know more, or, ho-hum? Any feedback is welcome; will return with recent focus later! Many thanks

Duncan Cragg 2023-10-12 12:25:47

CRDT-based?

And how is it different from SyncThing (that kind of question people ask which is SOOO annoying cos it usually means they didn't bother to read or understand what your offering is!)

George Svarovsky 2023-10-12 12:53:17

Yes, CRDT-based.

Heh no worries, all q's are good, shows me what I need to lead with in the docs 😀. So SyncThing is "not content-aware" – its atoms are opaque binary files. m-ld's atoms are numbers, strings, booleans etc. that live in a graph. (The graph could locally be represented as an object model, or structs with pointers, or whatever.) So what you're sharing is the application-specific data model, which might often correspond, when serialised, to the contents of a file.

Duncan Cragg 2023-10-12 16:02:48

Great answer, thanks, that's very clear.

So on permissions: is there a primary owner that configures write-permitted collaborators per (fine-grained) graph chunk? And I'd guess a kinda separate read permissions for more people to see bigger chunks of your graph?

Konrad Hinsen 2023-10-12 16:42:46

This looks at the same time (1) very interesting and (2) scary.

Very interesting for what it allows to do - I guess I don't need to expand on this.

Scary because it encourages "apps" to enclose data in silos (the clones), which is the exact opposite of what I am hoping and advocating for.

I do understand that apps can store the cloned data in persistent storage, such as a file system, in any format they like, and thereby make it accessible to other apps. But the focus of the documentation is on apps that "own" the user's data.

George Svarovsky 2023-10-12 17:52:07

So on permissions: is there a primary owner that configures write-permitted collaborators per (fine-grained) graph chunk? And I'd guess a kinda separate read permissions for more people to see bigger chunks of your graph?

There's a 'grand vision' flavour of answer and an implementation-specific one. To start with the latter, let me first say that m-ld chunks the world into 'domains', which are generally expected to be file-size things, which are cloned in-full. Each domain is its own graph, and the convergence guarantee covers the contents of that domain.

Read permissions in practice (so far) have been nicely covered by just controlling who has access to the messaging channel for that domain. For example, using MQTT, the channel is a Topic, which can be access controlled.

The baseline position for write permissions is, everyone has them – the component is intended for multi-editor writing. But that's not going to be satisfactory for every use-case. I did a whole research project on decentralised fine-grained write permissions. The long answer is here. In short, the domain starts with the first "genesis" clone, which establishes the security model and its local user, identified by public key, as the authority over everything. After that, permissions can change by an 'agreement', which is a data update that disallows any concurrent update and so can be used to establish a kind of chain of custody which can be independently verified at each node. At the moment this model is tricky to set up and not well enough characterised, so for now, fine-grained write permissions are definitely in the realm of the experimental.

To return to the grand vision: we're pretty sure we can make domains less physically-bound, and be able to have big domains which are cloned only in part, as required. That would first require some refinements to the 'agreements' model. But also, these ideas go hand-in-hand with having untrusted nodes, which is the tricky bug-bear of any attempt to decentralise authority. (Sorry about the hand-waving. More thoughts on this are in the long answer linked above, in the 'trust' section at the end.)

George Svarovsky 2023-10-12 18:09:27

But the focus of the documentation is on apps that "own" the user's data.

Ah! That's great feedback, thanks, I definitely need to address that focus!

So, we're hoping the design of m-ld will actually encourage apps not to be parochial about their data structures. It's based on the W3C's Resource Description Framework (RDF). So it buys into a world of well-defined tools and techniques for data, including the ability to declare the data model in the data itself. I'm hoping that will encourage the use of standard and shared vocabularies.

This is the same fundamental choice as in the Solid Project, if you're familiar with that. As a component rather than a platform, we don't have the same opportunity to transform data ownership like they do. (It'd be great to explore how Solid and m-ld work together though.)

Konrad Hinsen 2023-10-12 19:10:57

Thanks @George Svarovsky, that sounds a lot better than my first impression! A combination of m-ld with Solid sounds very interesting. The pod would provide the common reference that multiple apps can refer to.

Jack Rusher 2023-10-13 08:17:00

My talk on geometric algebra from this year’s Strange Loop/Papers We Love Conference, embedded in a mini-site with the video, a transcript, and links to all the papers I mention.

jackrusher.com/pwl-2023

📝 Geometry to Algebra and Back Again

4000 Years of Papers

Arcade Wise 2023-10-13 13:32:31

Your talk was one of my favorites! To be perfectly honest I haven't seen one of your talks before, so I was interested to see if it lived up to the hype but it totally did!

Jack Rusher 2023-10-13 08:18:41

A look at what Sam Ritchie has been working on with Emmy, a Clojure computer algebra system ported from Sussman’s scmutils, that also features quite a bit of Clerk:

youtube.com/watch?v=Jv2JgzAl5yU

… some of you might see where all of this is going — an open source, Clojure-based Mathematica-like system.

Arcade Wise 2023-10-13 13:32:47
: fizzBuzz? ( n -- ) "" swap ( str n -- )

   ( str n n ) dup 3 % 0 = ( str n ) if swap ( n str ) "Fizz" concat ( n strFizz ) swap then

   ( str n n ) dup 5 % 0 = ( str n ) if swap ( n str ) "Buzz" concat ( n strFizz ) swap then

   concat .

;



1 100 do i fizzBuzz? loop

I have been working on a forth implementation, and this fully works now! I'm super excited to show the cooler stuff that goes along with it too :>

Arcade Wise 2023-10-13 13:39:48

image.png

Arcade Wise 2023-10-13 14:18:22

Woo!!

Arcade Wise 2023-10-13 14:22:43

Fully I CAN'T BELIEVE ITS NOT FORTH user interface!

Arcade Wise 2023-10-13 14:24:46

the HTML output is actually a little iframe, which is quite nice for sandboxing

Eli Mellen 2023-10-13 14:33:46

can you target output outside of the iframe, or are you confined to that iframe?

Eli Mellen 2023-10-13 14:34:19

my terrible guava thing lets you hit arbitrary parts of the dom and modify them and I think that was a design mistake on my part. I like the idea of using an iframe and sandboxing output to a well known area

Arcade Wise 2023-10-13 14:41:12

Oh yeah! It's sandboxed to the iframe, the render function writes the html directly, which is horrific, but this whole project is held together by wishful JS

Arcade Wise 2023-10-13 14:51:21

Oh my god we did the same thing! That's amazing.

Arcade Wise 2023-10-13 14:52:10

Dang, you have a much cleaner implmentation! And in vanilla JS too.

Eli Mellen 2023-10-13 14:55:44

A lot of the bones were laid by felix, whose work I forked.

It allows you to target any old dom element and modify it..which is fun in a hacky way, but not particularly safe.

the pokedex word is useful for playing with that

Arcade Wise 2023-10-13 15:01:12

ooo

Arcade Wise 2023-10-13 17:01:02

If you wanna play around with this, I just added url loading!

arcades.agency/ICBINF/?loadfile=https://doggo.ninja/VoPUzO.icbinf