@harmon25 @webdeb I started a channel livedata on Elixir Slack, let’s connect there and kick it off 
methyl
0
justinmcp
Looks like I am pursing a similar idea over at GitHub - justinmcp/taper: Taper is a React (with SSR) and server-side-redux-like environment for Elixir+Phoenix. · GitHub. You can render react components directly from a template (.html.jsx) and they can connect to a server-side version of redux (basically the same API as redux). It can also render jsx server side only, skipping hydration on the client. There is currently one example at GitHub - justinmcp/taper-examples: Examples for the Taper project · GitHub.
Still really early days. I want to put back a “remote call” hook that could call out to any gen_server, handle store loading/persistence in a reasonable way, etc, etc.
Shaping up nice though.
3
harmon25
That is awesome!
Looks like a lot of the same thoughts we are pursuing. Join us on the livedata slack group if you haven’t already, and we can collab on these ideas!
Thinking there is room for both a lower level API that could be dropped into a phoenix app for server-side state in your JS client, and something that integrates them together more, for a fullstack next.js(ish) Elixir framework - which does server-side react rendering, and wires it all up - which is what taper is shaping up to be…
One thing we have implemented is sending json-diffs, akin to live_view diffs. Taper is just sending the entire state each time from the looks of it. Think there is room for some testing to determine if the json diffing actually helps at scale. I could imagine if the json is not very big - the diff might actually be more bytes than just sending the full json. It also of course comes at a cost of calculating the diff, also on the client applying it…
2
justinmcp
Thinking there is room for both a lower level API hat could be dropped into a phoenix app for server-side state in your JS client
One thing we have implemented is sending json-diffs, akin to live_view diffs. Taper is just sending the entire state each time from the looks of it.
100%. Sounds like a good idea. I have vaguely worked out having the reducers return a ecto.changeset instead of the entire new state, and then sending the changeset across the wire.. I’m still not 100% on the idea though, maybe just a json-diff thing is better as you say.
I’ll pop into the channel and we can chat about it all.
1
webdeb
Guys, I started working my initial state as a service idea, which should be a simple way to share state. I call it livestate (livestate.io) And I would love you to check it.
The code is open source, and very basic livestate.io · GitHub
@methyl I liked your solution for special purpose state very much, as it made possible to use type generation for TS, and custom methods. And it was actually your ideas which inspired me to go with the json-patch method 
1
Miserlou
I’ll throw my hat into the ring too, I guess.
Just pushed an alpha of this:
https://github.com/Miserlou/live_json
Built for my own needs, but maybe it’ll be handy for you as well.
It’s very simple and works with existing LiveViews - just use LiveJson.push_patch the way you’d use assign or push_event. It has two modes, jsondiff and rfc mode, which use Jsondiff and JSON-Patch, respectively. jsondiff mode is very fast, and rfc mode is compatible everywhere.
As an example you can:
def handle_info({:new_data_to_visualize, new_data} = _event, socket) do
{:noreply,
socket
|> push_patch("viz_data", new_data)
}
end
Then, in your JS console:
window.viz_data
// {1: ["a"], 2: ["b"] ... 99999: ["zzzzz"]}
Only deltas are sent over the wire, so it’s quite fast!
More details soon, but works for me.
5