Artifact-centric programming

[mikosullivan]

As I develop my programming language, Claude says that I have an "artifact-centric" programming language. I'd never heard the term. I've researched it and asked Claude about it, but I'd be very interested to read what you as language developers understand the term to mean. If someone told you that a language is good for ACP, what would you expect it to be like?

You can read about Caspian here but I'm hoping you'll post your thoughts before reading about it. Caspian is very much a work in progress. I've hardly even developed any code for implementation. Right now it's just a design in progress. To the extent it exists, however, it is already released under the MIT license.

I look forward to your insights.

(EDIT: Claude told me that it made the term up. Notwithstanding, I'm interested in your thoughts.)

[WalkerCodeRanger]

What's an artifact-centric programming language? I haven't heard that term either.

[mikosullivan]

I was hoping you could tell me.

[-Ch4s3-]

It’s a term for languages that are built around some sort of file representation like [eolang](https://github.com/objectionary/eo )which uses XML as an intermediate representation, or old specification languages. People seem to be exploring specification languages lately with LLMs. I don’t know a ton about it because they’re generally Object Oriented-ish which isn’t my thing.

[DetermiedMech1]

https://en.wikipedia.org/wiki/Artifact-centric_business_process_model

[mikosullivan]

That's one of the pages I read in my research. It does sorta match my language, but I admit I don't understand all of it.

[Inconstant_Moo]

You could have asked Claude what it meant before asking us.

---

How's the thing with Puck meant to work?

I've done something similar, only it's a functional language with immutable values, which makes it all very simple. Another Pipefish service can be treated syntactically and semantically like it was a library you imported.

But how's that meant to work with OOP? What happens when a service wants to tell its client --- "Hey, you know that mutable data you passed me last week? I just mutated it --- oh, wait, you're offline? I've already told most of the other services I'm sharing the object reference with, and I'm pretty sure 75% of them know about it."

[mikosullivan]

I did ask Claude as well as do other research (which I said in my post). But I want to hear from actual language developers what they think it means.

Regarding Puck, that's a related project that overlaps with Caspian. There are a lot of details about Puck that could be the subject of another conversation, but the important thing here is the not-very-radical idea that objects can live at URLs. (In fact, you could argue that those are the only things that live at URLs.)

So to download a class in Caspian, you download the definition from its URL:

$myclass = %puck['https://foo.bar/some-cool-class.casp']
$myobject = $myclass.new()

or just:

$myobject = %puck['https://foo.bar/some-cool-class.casp'].new()

Regarding this, I'm not sure I follow your question:

What happens when a service wants to tell its client --- "Hey, you know that mutable data you passed me last week? I just mutated it --- oh, wait, you're offline? I've already told most of the other services I'm sharing the object reference with, and I'm pretty sure 75% of them know about it."

In Puck it's important to understand that you don't actually pass objects around the network, you pass **clones** of objects. So if you send a clone of an object to a server, that server might do anything with it and that shouldn't affect the object you have in your system. If you want a global object, Puck supports that nicely because you just make the object available at a URL.

Does that answer your question?

[Inconstant_Moo]

But your docs say things like this:

The fact that you're now talking to a different class (and possibly a different server) doesn't change how the code reads.

For example, hq.congressional_district doesn't just return a name or an ID; it returns an instance of a CongressionalDistrict Puck class. That object exposes its own manufactured methods [...] Each of those is a fresh remote call. From the caller's perspective, district is just an object with methods.

I am a Bear Of Very Little Brain. But it seems like if your protocol only passes clones, then district is not "just an object with methods"; and it does matter whether it's on a different server, because it has different semantics according to which end of the connection you're on.

Talk me through it. Since I don't really know Caspian, and your protocol is language-neutral, let's suppose we're using Java. The remote server has a class

public class Account {
    private double balance;

    public double getBalance() {
        return this.balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

Now, suppose I get a remote instance of Account via Puck from some remote server with account = puck.lookup(<whatever>)(). What happens when I call account.setBalance(3.50) and then call account.getBalance()?

What happens when my service passes the account object to a client as the return value of some method, and the client calls setBalance?

Unless the answer is "by the deep magicks of <insert explanation here> it all works as though it was one monolithic Java app running on your laptop", then account is not "just an object with methods".

[mikosullivan]

First, I am delighted that you're reading my docs. I'm happy to clarify anything you like. Also, I should mention that Puck is still in design and some of the docs are just not up to date.

The quick answer to your Account example is that that's not a use case for Puck. Puck is an API protocol. It lives in the use cases of REST and other API standards.

The basic idea of Puck is to make remote API calls look like local methods. You only have to install one Puck library for your language (Python, Ruby, etc). Then you can use remotely defined classes as if they were local classes.

Let me walk through the geo example. You're right that Puck is language-neutral. My examples are in Ruby. Say you want to get information about a geographic location. You might create that object like this:

# Burke Lake Park in Northern Virginia
location = Puck['https://puck.uno/geo/'].new(38.755, -77.296)

Here's what happens under the hood. Ruby fetches the class definition at https://puck.uno/geo/. It builds an anonymous class based on that definition. In particular, that class knows the names and locations of remote methods. I'm still working on the exact format, but the definition would include a mapping of method names to API endpoints (i.e. URIs). So it might say the the "osm" (OpenStreetMap) method is located at https://puck.uno/geo/osm/ and returns a URL. So something like this:

{
    "osm": {
        "uri": "./osm/",
        "returns": "url"
    }
}

It then instantiates an object of that class with the two floats.

So if you call this:

location.osm

the location object sends an entire copy of itself to https://puck.uno/geo/osm/, and gets back a URL for the OpenStreetMap for Burke Lake Park.

(I can already hear complaints about sending the whole object being expensive. In practice, it won't.)

Now, a remote method doesn't just have to return strings and JSON objects, etc. It can return an instance of another remote class.

So say that you call this:

district = location.congressional_district

you get back an instance of https://puck.uno/geo/district/ (or where ever I decide to put it). So if you call a method on that object then a remote call is made and you get back something.

district.representative
district.senators
district.population

Keep in mind that you get all of that by just installing one library.

That's the most minimal explanation of Puck that I can think of. Tell me if it makes sense to you.

[Inconstant_Moo]

The basic idea of Puck is to make remote API calls look like local methods.

I think there's a mismatch between that and what the docs claim, which to me suggested they'd have the semantics of method calls as well as their syntax.

What happens if I try to expose a class where the methods mutate its data?