stebalien changed the topic of #ipfs to: Heads Up: To talk, you need to register your nick! Announcements: go-ipfs 0.4.18 and js-ipfs 0.34 are out! Get them from dist.ipfs.io and npm respectively! | Also: #libp2p #ipfs-cluster #filecoin #ipfs-dev | IPFS, the InterPlanetary FileSystem: https://github.com/ipfs/ipfs | Logs: https://view.matrix.org/room/!yhqiEdqNjyPbxtUjzm:matrix.org/ | Forums: https://discuss.ipfs.io | Code of Con
rawriclark has joined #ipfs
rawriclark has quit [Client Quit]
rawriclark has joined #ipfs
spinza has quit [Ping timeout: 245 seconds]
cyfex_ has joined #ipfs
cyfex has quit [Ping timeout: 268 seconds]
Mateon3 has joined #ipfs
Mateon1 has quit [Ping timeout: 245 seconds]
Mateon3 is now known as Mateon1
pdinkins has joined #ipfs
pdinkins has quit [Client Quit]
aarshkshah1992 has joined #ipfs
alexgr has quit [Ping timeout: 246 seconds]
krjordan has joined #ipfs
krjordan has left #ipfs [#ipfs]
aarshkshah1992 has quit [Remote host closed the connection]
aarshkshah1992 has joined #ipfs
spinza has joined #ipfs
xcm has quit [Remote host closed the connection]
xcm has joined #ipfs
lordcirth_ has joined #ipfs
lordcirth_ has quit [Remote host closed the connection]
lordcirth_ has joined #ipfs
theon has joined #ipfs
lordcirth has quit [Ping timeout: 246 seconds]
theon has quit [Client Quit]
kjwek has joined #ipfs
uzyn has joined #ipfs
reit has quit [Ping timeout: 268 seconds]
xcm has quit [Remote host closed the connection]
henriquev has joined #ipfs
xcm has joined #ipfs
Belkaar has quit [Read error: Connection reset by peer]
aarshkshah1992 has quit [Remote host closed the connection]
Belkaar has joined #ipfs
Belkaar has joined #ipfs
toxync01 has quit [Remote host closed the connection]
khlieng_ has joined #ipfs
toxync01 has joined #ipfs
lidel` has joined #ipfs
lidel has quit [Ping timeout: 245 seconds]
lidel` is now known as lidel
charlton has joined #ipfs
aarshkshah1992 has joined #ipfs
charlton has quit [Quit: 💪👁👄👁🤝👁👄👁👉 c y a]
cyfex has joined #ipfs
}ls{ has quit [Ping timeout: 246 seconds]
cyfex_ has quit [Ping timeout: 272 seconds]
}ls{ has joined #ipfs
user_51 has quit [Ping timeout: 268 seconds]
user_51 has joined #ipfs
_whitelogger has joined #ipfs
lordcirth has joined #ipfs
lordcirth_ has quit [Ping timeout: 272 seconds]
aarshkshah1992 has quit [Remote host closed the connection]
aarshkshah1992 has joined #ipfs
aarshkshah1992 has quit [Remote host closed the connection]
lassulus_ has joined #ipfs
lassulus has quit [Ping timeout: 250 seconds]
lassulus_ is now known as lassulus
lindeb has quit [Ping timeout: 272 seconds]
leb__ has quit [Ping timeout: 240 seconds]
leb__ has joined #ipfs
ismay has joined #ipfs
aarshkshah1992 has joined #ipfs
xcm has quit [Read error: Connection reset by peer]
xcm has joined #ipfs
aerth has quit [Ping timeout: 256 seconds]
aerth has joined #ipfs
uzyn has quit [Quit: uzyn]
uzyn has joined #ipfs
lordcirth has quit [Remote host closed the connection]
lordcirth has joined #ipfs
aarshkshah1992 has quit [Remote host closed the connection]
aarshkshah1992 has joined #ipfs
obensource has quit [Ping timeout: 245 seconds]
<mikolalysenko>
anyone here ever thought about how to make a crdt register with undo?
aarshkshah1992 has quit [Remote host closed the connection]
<aschmahmann[m]>
there are a number of papers online about how to do CRDTs with undo. It frequently boils down to what do you mean by undo and what behavior you're actually looking for.
obensource has joined #ipfs
<aschmahmann[m]>
for instance some of the undo CRDTs are basically counters of undo/redo that are applied to each CRDT operation. So the sequence (apply opA), (apply opA), (undo opA) results with opA being applied since 1+1+(-1) > 0
aarshkshah1992 has joined #ipfs
kapil____ has joined #ipfs
Pulse2496 has joined #ipfs
<mikolalysenko>
aschmahmann[m]: yeah, basically i want to implement some register with whatever semantics are most efficient. i can do last writer wins, but also want to support some kind of undo functionality
aarshkshah1992 has quit [Remote host closed the connection]
aarshkshah1992 has joined #ipfs
<aschmahmann[m]>
mikolalysenko: The easiest I can think of right now is just wrapping a PN-Counter around the operations you want to undo/redo (if you don't want to enable redo, you can just have a simple undo operation that is a G-Set). The difficulty tends to be in how you relate your UX of what you are "undoing" to the CRDT elements/operations you want to undo. However, if it's something easy like a TODO list where you are undoing and
<aschmahmann[m]>
redoing checkmarks that's pretty straightforward to implement.
<mikolalysenko>
these registers could store many possible values, like strings, etc.
<mikolalysenko>
basically i want to implement a ui where users can adjust a bunch of controls and i want it to be responsive and also support undo
<mikolalysenko>
so these controls can be things like random sliders, drop downs, color pickers, etc.
<mikolalysenko>
there's a large but finite amount of them
<mikolalysenko>
also i can timestamp events on the server so i can put an order on operations
<aschmahmann[m]>
but what happens if Alice moves the slider left -5 and Bob moves the slider right +7. The changes synchronize and the result is +2. What happens when Alice presses undo?
<mikolalysenko>
but also need a safe way to apply operations optimitically and locally
<mikolalysenko>
in that case it would be easier since the slider could be modeled as an integer with addition/subtraction so it's an abelian group
<mikolalysenko>
the harder case is when both alice and bob try to fight over the name of an entity
<mikolalysenko>
like alice sets color to blue, bob to red, alice does an undo
<aschmahmann[m]>
Well Alice sees Bobs operation after her own. Alice's undo could mean undo the last thing I saw (Bob's +7) and so the result is -5. Alternatively, Alice could mean to undo her last change (-5) and so the result is +7.
<mikolalysenko>
would have to be alice's last change since users are concurrently editing stuff
<mikolalysenko>
i experimented with a global undo, it was terrible
}ls{ has quit [Quit: real life interrupt]
<mikolalysenko>
like you start to undo stuff and someone else is changing things and then everyone gets confused
<aschmahmann[m]>
from a CRDT perspective it doesn't really matter whether you chose the answer as -5 or +7, it's a UX thing. All it changes is whether you send the operation (UNDO AliceOp) or (UNDO BobOp).
<mikolalysenko>
yeah, in this case there is a clear "best ux" choice
<mikolalysenko>
alice can only undo alice's last action, not bob's
<aschmahmann[m]>
If you want (UNDO AliceOp), then your case with the colors gets resolved easily too. The color ends up red
<mikolalysenko>
well: imagine counter is initially black. alice sets to red, bob sets to blue, alice does undo
<mikolalysenko>
does it stay blue or go back to black?
random_yanek has quit [Ping timeout: 244 seconds]
<mikolalysenko>
also and if it goes to black, then how to handle bob pressing undo?
vandemar has quit [Ping timeout: 246 seconds]
kjwek has quit [Ping timeout: 246 seconds]
<aschmahmann[m]>
it's totally case dependent on what your users identify better with (e.g. there may even be some scenario where the colors are really RGB values which makes this the number case again). However, I would argue that if you set the color to black then the operation should not be an undo but just (SetColor Black).
<mikolalysenko>
then bob's undo would be "set color red"?
<mikolalysenko>
i mean the way it would be more logical is if we have a sequence of operations on it and then you look at undo as retroactively deleting an operation from the sequence
<mikolalysenko>
but this could be expensive since it seems like you'd need to track all operations for each register
<aschmahmann[m]>
sure you can do it the photoshop "delete from history" route
<aschmahmann[m]>
but just like photoshop files keeping the history has a cost, which may/may not be worth while in your situation
<mikolalysenko>
you could implement something like this using a heap i guess, but i guess i'm asking if there's a way to maybe make this work using less space
<mikolalysenko>
ideally constant space would be cool, but even something like log overhead in the number of operations would be ok
<aschmahmann[m]>
realistically if you're chosing an operation based CRDT instead of a delta CRDT or something else like that you may end up benefitting from keeping operations around anyway
<mikolalysenko>
yeah, one log of all operations is ok but i want to keep the actual state data structure light weight
<mikolalysenko>
since it would be nice to serialize/copy it around etc
<mikolalysenko>
the more complex the state data structure becomes the more unweildy it becomes to do anything with it
<aschmahmann[m]>
if you can make your operations invertible then you're still fine
random_yanek has joined #ipfs
<mikolalysenko>
realisitically not going to be possible here, the operations are just write a random value to a register
<mikolalysenko>
i can solve consensus by putting an ordering on the operations
<mikolalysenko>
since this app is a client-server architecture we can just linearize everything on the server side
<mikolalysenko>
but we still need to make it fast for users to do stuff locally and synchronize their changes eventually with other users
<mikolalysenko>
2 ways i can think of doing this right now are: 1) instead of undo make it just set the register to the previous value or 2) track the set of all values in a 2phase set, make undo delete the last write from the set
<mikolalysenko>
the 1st approach seems like it will screw up when multiple people do an undo, the 2nd approach seems really inefficient to turn every register into a set
<aschmahmann[m]>
why would you need a 2P-Set?
<mikolalysenko>
well you want a set with remove and you only need to remove at most once
<aschmahmann[m]>
it feels like it should either be a PN-counter, or a one element G-Set
<aschmahmann[m]>
ok sure, just thinking of it differently (I was thinking per element and you're writing globally)
<mikolalysenko>
yeah we would need the set to track the history of all operations so far applied to the register
<mikolalysenko>
and then have a remove for the undo
<mikolalysenko>
it's a bit excessive right? maybe it can made faster
<mikolalysenko>
maybe there's some weird retroactive data structure thing i've never heard of that solves this problem
<aschmahmann[m]>
you said before that your operations can't be invertible, are you sure that's correct? Because it seems like if you are writing arbitrary text you could either use a text based CRDT (like RGA) or your option 1. While I agree that option 1 might be annoying with multiple concurrent redos, the Google Docs way of solving this by having a chat bar in the document is basically the only way to deal with concurrency conflicts
<aschmahmann[m]>
anyway.
<mikolalysenko>
the data is mostly stuff like select a field from a drop down, toggle a check box, etc.
<mikolalysenko>
think filling in a form
<mikolalysenko>
"collaborative tax returns"
<mikolalysenko>
if you try something like sequence crdts (ala google docs) it'd easily end up with invalid data
<mikolalysenko>
alright, you've convinced me 2 phase set is the only way to do this
<mikolalysenko>
thank you
<aschmahmann[m]>
np, happy to be of some help. I'd also briefly consider whether it might be helpful to have some basic chat if users really need to communicate about filling out their form
<aschmahmann[m]>
it's the approach Google Docs tried and I think basically deals (in a cop out way 😄) with the simultaneous and confusing changes problem
aarshkshah1992 has quit [Quit: Leaving...]
fazo has joined #ipfs
ylp has joined #ipfs
Ai9zO5AP has joined #ipfs
gmoro has joined #ipfs
rendar has joined #ipfs
vyzo has quit [Quit: Leaving.]
rawricla1k has joined #ipfs
vyzo has joined #ipfs
rawriclark has quit [Ping timeout: 246 seconds]
alexgr has joined #ipfs
kapil____ has quit [Quit: Connection closed for inactivity]
reit has joined #ipfs
jon1012 has quit [Quit: Ping timeout (120 seconds)]
jon1012 has joined #ipfs
ekardnam has joined #ipfs
saki has joined #ipfs
uzyn has quit [Quit: uzyn]
cyfex has quit [Quit: WeeChat 2.2]
cyfex has joined #ipfs
gmoro has quit [Ping timeout: 240 seconds]
woss_io has joined #ipfs
lnostdal has quit [Ping timeout: 240 seconds]
lnostdal has joined #ipfs
ygrek has joined #ipfs
spinza has quit [Quit: Coyote finally caught up with me...]
<Swedneck>
did this room get bridged to another channel?
<Swedneck>
i thought this was #ipfs
gmoro has joined #ipfs
<Harekiet>
bridged on matrix?
mowcat has joined #ipfs
spinza has joined #ipfs
dethos has joined #ipfs
alexgr has quit [Remote host closed the connection]
<ValdikSS>
Hello, for some reason IPFS does not return correct last-modified HTTP header if the file accessed using IPFS hash /ipfs/something, but it does return it if you use ipns or domain with _dnslink
<ValdikSS>
last-modified: Thu, 01 Jan 1970 00:00:01 GMT
joocain2 has quit [Ping timeout: 256 seconds]
joocain2 has joined #ipfs
rcat has joined #ipfs
cyfex has quit [Ping timeout: 250 seconds]
rcat has quit [Client Quit]
rcat has joined #ipfs
cyfex has joined #ipfs
zeden has joined #ipfs
cyfex_ has joined #ipfs
zeden has quit [Client Quit]
zeden has joined #ipfs
cyfex has quit [Ping timeout: 264 seconds]
lordcirth has quit [Remote host closed the connection]
lordcirth has joined #ipfs
skeithc has quit [Quit: Konversation terminated!]
leb__ has quit [Ping timeout: 250 seconds]
cris has quit []
cris has joined #ipfs
tombusby has quit [Remote host closed the connection]
aerth has quit [Ping timeout: 256 seconds]
aerth has joined #ipfs
Elon_Satoshi has joined #ipfs
Copenhagen_Bram has quit [Ping timeout: 252 seconds]
obensource has quit [Ping timeout: 268 seconds]
malaclyps has quit [Read error: Connection reset by peer]
malaclyps has joined #ipfs
Mo0O has quit [Quit: WeeChat 1.9.1]
obensource has joined #ipfs
}ls{ has joined #ipfs
leb__ has joined #ipfs
leb__ has quit [Ping timeout: 264 seconds]
airwind has joined #ipfs
ctOS has quit [Quit: Connection closed for inactivity]
Wioxjk has quit [Ping timeout: 240 seconds]
airwind has quit [Quit: airwind]
<Kubuxu>
@ValdikSS what does it retrun last-modified at all?
kapil____ has joined #ipfs
Wioxjk has joined #ipfs
cyfex has joined #ipfs
vijayee has joined #ipfs
cyfex_ has quit [Ping timeout: 250 seconds]
uzyn has joined #ipfs
aerth has quit [Ping timeout: 256 seconds]
aerth has joined #ipfs
<ValdikSS>
Kubuxu: if used with domain or /ipns, yes
Wioxjk has quit [Ping timeout: 272 seconds]
agsv has joined #ipfs
Wioxjk has joined #ipfs
vijayee has quit [Ping timeout: 264 seconds]
MDude has quit [Ping timeout: 240 seconds]
<Kubuxu>
@ValdikSS last-modified is not needed because we send ETag and also mark it immutable
mowcat has quit [Remote host closed the connection]
<Kubuxu>
or looking at it we don't mark it immutable but we still send ETag
<ValdikSS>
Kubuxu: Why is it set for /ipns and domains then? I used this feature and it was a surprise that Last-Modified is not set for /ipfs.
<Kubuxu>
Because in case of ipns and domains we roughly know when was the record published
<Kubuxu>
thus infer when it was modified
<Kubuxu>
in case of /ipfs/ we can't know that
<Kubuxu>
Looking at it, we set it to Thu, 01 Jan 1970 00:00:01 GMT
dethos has quit [Ping timeout: 245 seconds]
<ValdikSS>
Kubuxu: It also work for domains pointing to /ipfs in _dnslink. How that works?
<Kubuxu>
Not sure ;p
MDude has joined #ipfs
<Kubuxu>
It is not definitive time.
<Kubuxu>
It is the time that given server is sure that content was not modified.
<Kubuxu>
In general use ETag instead for checking chaches.
<Kubuxu>
s/chaches/caches/
<Kubuxu>
May I ask what are you doing?
<ValdikSS>
Kubuxu: I'm serving proxy auto configuration (PAC) file for browsers and for Chrome extension. The extension checks last-modified (but that could be easily changed). It was just strange to me that /ipfs/ URL does not return last-modified but domain with the same /ipfs in dnslink does.
<Kubuxu>
As I said, looking at it /ipfs/ does.
<Kubuxu>
It is set to unix time 0.
<Kubuxu>
sorry, unix time 1
<Kubuxu>
01 Jan 1970 00:00:01 GMT
<ValdikSS>
Well, try that with domain, it would return close-to-real time
<ValdikSS>
And you're correct that it does not return real last modified time. I missed that.
<Kubuxu>
I know, for /ipns/ it will be close to real time
<Kubuxu>
or Host:
<Kubuxu>
because it will be the time we last resolved dns/ipns record
<Kubuxu>
I think
<ValdikSS>
Kubuxu: no, for ipfs to, but on domain
<ValdikSS>
Take a look at docs.ipfs.io. There's /ipFs/ record on domain, and it does return last-modified
<agsv>
what is the difference between `ipfs pubsub peers` and `ipfs swarm peers`?
leb__ has joined #ipfs
<geoah>
pubsub I assume are the peers who you are chatting with and have pubsub enabled I guess, while swarm is all the peers you are chatting with
<agsv>
oh cool, can I tell what topics are they listening for?
Wioxjk has quit [Ping timeout: 268 seconds]
stoopkid has joined #ipfs
<geoah>
not sure, you can probably increase verbosity and look at the logs, but I don't think there is a better way through the cli
dsiypl4__ has joined #ipfs
ylp has quit [Remote host closed the connection]
xcm has quit [Ping timeout: 245 seconds]
xcm has joined #ipfs
kapil____ has quit [Quit: Connection closed for inactivity]
cyfex_ has joined #ipfs
cyfex has quit [Ping timeout: 272 seconds]
<agsv>
what does this error means? pubsub: opening new stream to peer: protocol not supported <peer.ID Qm*DVTzeg> <peer.ID Qm*VYxzGC> notify.go:22
saki has quit [Ping timeout: 240 seconds]
<agsv>
what protocol
Wioxjk has joined #ipfs
ismay has quit [Ping timeout: 250 seconds]
ygrek has quit [Ping timeout: 250 seconds]
cyfex_ is now known as cyfex
spinza has quit [Quit: Coyote finally caught up with me...]
<geoah>
agsv: this sounds like a multistream error, so I assume that that peer doesn't support the protocol you are trying to use -- what's the address you are trying to dial? (feel free to redact ids/ips)
<agsv>
geoah, no idea, I raised pubsub verbosity to debug and this message stars all over the log
<agsv>
actually its warn level, so it has nothing to do with the verbosity
reit has quit [Ping timeout: 268 seconds]
<geoah>
owh, I'm not sure how peers advertise the fact they are running pubsub -- so it might just be that they just try to "talk pubsub" with any peer they connect to.
<agsv>
the fact im behind a double NAT might have something to do with this?
<geoah>
I really don't think so, I just think it's that the other peer doesn't support this protocol, it's not an issue on either side
<geoah>
I'd suggest waiting for someone more knowledgable to answer this :D
spinza has joined #ipfs
<agsv>
geoah, yes I guess its spamming that nobody supports pubsub. back to the original problem: I paired two nodes and subbed in one node to a given topic. the other node console points nothing about this.
jamiew_ has quit [Ping timeout: 250 seconds]
joeyh has joined #ipfs
cyfex_ has joined #ipfs
cyfex has quit [Ping timeout: 244 seconds]
chiui has quit [Ping timeout: 240 seconds]
<agsv>
another question, is `ipfs pubsub peers` contained in `ipfs swarm peers`?
<agsv>
or when wanting to talk directly to a pubsub peer you need first to find a method of communication
Adbray has quit [Remote host closed the connection]
uzyn has quit [Quit: uzyn]
craigo has joined #ipfs
jesse22 has joined #ipfs
Adbray has joined #ipfs
anthony has quit [Ping timeout: 250 seconds]
xcm is now known as Guest82150
xcm has joined #ipfs
Guest82150 has quit [Ping timeout: 268 seconds]
<geoah>
agsv: iirc (i really have only seen old versions of pubsub so I might be way off) when you wanna sub to a topic, you query the dht with the topic you want, prefixed by a static key mentioning something about ipfs/pubsub. The peer this results will be dialled and it will attempt to negotiate the pubsub protocol. These peers will end up in your swarm.
<agsv>
but what will happen when both peers are behind nat?
<agsv>
this is where relay circuit comes in play?
jesse22_ has joined #ipfs
jesse22 has quit [Ping timeout: 246 seconds]
woss_io has quit [Ping timeout: 268 seconds]
The_8472 has quit [Ping timeout: 240 seconds]
kjwek has quit [Remote host closed the connection]
The_8472 has joined #ipfs
agsv has quit [Read error: Connection reset by peer]
<AuHau>
Do you know what is the purpose of `https://registry.js.ipfs.io/` (the default value of `ipfs-registry` parameter)? Does it supposes to serve some bootstrapping information? The URL timeouts for GET, so I am bit confused...
lnostdal has joined #ipfs
fazo has quit [Quit: fazo]
jakobvarmose has joined #ipfs
sbani has quit [Remote host closed the connection]
sbani has joined #ipfs
leb__ has quit [Ping timeout: 240 seconds]
xpitr has quit [Changing host]
xpitr has joined #ipfs
tombusby has joined #ipfs
spinza has quit [Quit: Coyote finally caught up with me...]
lvlinux has left #ipfs [#ipfs]
spinza has joined #ipfs
lindeb has joined #ipfs
Papa_Alpaka has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Mateon2 has joined #ipfs
Mateon1 has quit [Ping timeout: 250 seconds]
Mateon2 is now known as Mateon1
uncle_ben has joined #ipfs
<jacky>
is there a specification for ipfs?
<jacky>
or rather ipns?
<jacky>
I'm trying to see if I can make one's site "automatically" resolve via ipfs
<jacky>
but I'm not using node or Go
<jacky>
(using Elixir/Erlang)
dsiypl4__ has quit [Ping timeout: 244 seconds]
dimitarvp has quit [Quit: Bye]
vyzo has quit [Quit: Leaving.]
charlton has joined #ipfs
vyzo has joined #ipfs
pecastro has quit [Ping timeout: 240 seconds]
charlton has quit [Quit: 💪👁👄👁🤙 c a t c h i n' s o m e z z z s]