
Show HN: A note-taking web app that won't ever betray you - heathjohns
https://noteto.me/
======
gpm
This assumes that edsu will never betray you.

Given the broad meaning of betray used, that seems unlikely. If edsu gets big
it will have to pay for all that storage somehow. Like all things edsu will
one day come to an end, and like most websites/companies/endeavors it will
probably come to an end before I do.

~~~
marknadal
Edsu seems to rely on federated services.

Email, similarly, unfortunately fell to convenience - GMail, with Google
selling your data.

The parent brings up a good point, how do we know Edsu won't betray its users?
Or that it won't become dominated by a centralized provider?

I'd love to hear an answer.

For me, our team decided to take a route that _cannot_ be compromised - your
identity belongs to you, fully decentralized ([https://gun.eco/docs/Todo-
Dapp](https://gun.eco/docs/Todo-Dapp)), yet can do 0-server password resets
and other conveniences.

~~~
larkeith
I know I'm a bit of a broken record, but a <noscript> notice that JS is
required is always appreciated rather than a blank page.

~~~
marknadal
Apologies, yeah, the site has an interactive coding tutorial that teaches you
to write and run your JS. <noscript> would be good - make a PR?
[https://github.com/gundb/gun-
site/blob/master/docs/src/index...](https://github.com/gundb/gun-
site/blob/master/docs/src/index.html)

------
daliwali
This is my first time reading about Edsu, it seems very similar to the Solid
Platform in one important aspect: it keeps data in the control of the user,
separate from applications.

I like how low-level and simplified the protocol is, being limited to only 9
types of messages. Compared to Solid which carries baggage from RDF, this
seems far easier for third parties to implement.

The note-taking app is really under-selling the protocol beneath it. What
could help sell it better is by doing something better than a centralized
platform can.

~~~
heathjohns
Thanks! One of the goals of Edsu is that it's simple enough that you can
"telnet" in and just talk directly to the server like you can with HTTP or
SMTP. It can seem like a trivial feature, but I've found that being able to
speak a subset of a protocol from any language after just an hour or two of
duct-tape hacking ends up being a big unsung feature.

And itgoon has it right - this was the most useful thing I could think to
write that only took a single day (I had an self-imposed deadline to hit
earlier this week).

Here's a discussion of more interested projects and how Edsu could be used in
each (and its advantages and disadvantages):

[https://edsu.org/use-cases/](https://edsu.org/use-cases/)

~~~
karl42
Edsu seems to have some similarities to
[https://remotestorage.io](https://remotestorage.io) . Can someone summarize
the main differences?

~~~
heathjohns
From a quick look through remoteStorage, it looks to me like it's is focused
on storage (and so appropriately named!), while Edsu is more explicitly a
foundation for applications.

One place this shows up is that Edsu has a permissions model where other
people can read and interact with what you've stored (within very tightly
defined parameters), which is the basis for writing multi-user apps like, say,
a distributed Reddit or Slack.

They both have the same model regarding the ownership of data though. The
biggest difference there is that Edsu uses a Merkle tree as the storage, like
IPFS and git, which has a lot of consequences in terms of how it gets used.

------
nihil75
yey another note taking app... The digital equivalent of making ashtrays in
pottery class.

~~~
Waterluvian
I thought that was Todo lists? The hello world equivalent of web apps.

~~~
lostmsu
The technology improved a bit.

------
8bitsrule
"Write some text - it'll be here when you get back.... I can promise all this
because NoteToMe is an Edsu app. It means I don't have to store your data, you
do ...."

The same is true of the text file I've been adding to for decades. After
learning the hard way (several times) NEVER to trust someone else's
prog/assume they'll be around for more than 6 months. Multiple backups sync'd
religiously.

And ... _no_ website needed! Not even a net connection! Just a 'personal
computer'!

"You do have to sign up for an Edsu account...."

Whoops ... there it is.

------
podviaznikov
Hi, edsu seems very interesting. I've looked through examples and read docs.
Question: is it possible to make an app and allow user to set permissions.
E.g. lets say I have writing app. I want initially to create writings as
`private` and then promote them to `public`.

I don't see if it's possible. I see that scope is fixed for now in the name
like that `prv.app.edsu-org.hello-world.storage`. So I assume `token` only
works for `prv.app.edsu-org.hello-world.storage` but wouldn't work for
`pub.app.edsu-org.hello-world.storage` or would it?

~~~
heathjohns
Thanks for reading!

If an app wanted to be able to switch something from public to private or
back, it'd get a token with write permissions for _two_ names, one with the
prv.* prefix, and one with the pub.* prefix. And that's a good thing: it makes
it clear to the user that the app is requesting the ability to make the things
that they write public.

It's still just one grant request, it's just that there'd be two line items
instead of one. Also, names are simple pointers to blocks of data, so, for
instance, if both names happen to be pointing to the same written piece,
there's no duplication of data.

~~~
podviaznikov
And another question. It's not possible to list all the keys under some
namespace, right? `prv.app.edsu-org.prefernces-app.preferences` - I can't see
what are the subkeys?

And I see that there is no multi-get request. So how would you implement your
notes app if you have multiple notes, not one. Would you have a document which
would store hashes of all notes and then fetch in parallel all of them (making
n calls, 1 call per note)?

~~~
heathjohns
Names are big chunky things - you want to use them as sparingly as possible,
and in general they should be "well known" \- meaning a list function (which
does exist as pub.srv.edsu.listings.names, though it's currently not something
you can request permissions to) goes pretty hard against the grain of the
protocol.

Essentially, you'd only want more than one name if there's different
visibility requirements for different parts of your data, or you specifically
want to disconnect the state of some of data from others. All of your
structure (e.g. lists, trees, lookup tables, etc.) you want to keep in the
blocks.

So in your case of having multiple notes, you'd likely want the name _block_
to keep track of the block hash of each one (so, yes, exactly as you say). And
correct, if you wanted all of them you'd need to do N block-get calls.
However, due to pipelining and chaining, that's not as costly as it might
sound: in terms of latency it should be costless, and in terms of bandwidth
the overhead is a fraction of a percent if you're using full blocks (i.e. what
you'd be doing if you're concerned about bandwidth).

A lot of this stuff is quite low level (think almost SCSI kind of low level) -
it's meant to be abstracted away by libraries like basic-storage.js. In that
case, having multiple notes is trivial - you put each note under a different
storage key, and the library sorts out how to retrieve them efficiently and
update them independently, even though they're all be under the same name.

In case you haven't run into it yet, I talk a little bit more about why names
are meant to be used sparingly at [https://edsu.org/use-
cases/storage/](https://edsu.org/use-cases/storage/)

------
martin_ky
I like the concept of decoupling storage from the editor app. I wish more SAAS
providers recognized this as an important product feature. It would allow
deployment of hosted services in much wider range of scenarios, where privacy
and data ownership is a big concern.

------
Quanttek
It's not really clear to me how the data is stored. Is it confined to the Edsu
server I use akin to Diaspora and applications connect to it? How do I migrate
my data or switch providers? Is it lost if the server or my localStorage goes
down?

~~~
heathjohns
Thanks for your interest!

It is indeed stored on an Edsu server. The data format is trivial and
completely specified, so switching providers should be straightforward (an
Edsu app to do the data transfer would be easy to write, and I plan on writing
one). If you're using your own domain (which is encouraged), from there you'd
just update an A record to complete the transition, if not, you'd set up a
transparent redirect on your old host to keep all your old links/permissions
alive.

It's pretty old school in that if your provider loses a server and they're
_not_ doing replication/backups then there can be data loss. If they are, then
a failover should work fine, with minimal loss and no corruption (the
important stuff is atomic).

With localStorage, how it's used is up to the app (generally it'd only be used
for keeping a token and maybe a block cache), so I wouldn't expect a loss of
that to matter in most cases.

~~~
Quanttek
Thanks for the helpful reply! I brought up local storage because people were
talking about some kind of sync and it sounded like the browser's storage
would be used

------
gtt
I actually found that using special directory for notes and git and grep is
actually convenient. The only thing I'm missing is fuzzy search features of
grep, like build on word2vec models.

~~~
h1d
Can we call this the Dropbox syndrome where people boasts they have a better
solution with combination of cli tools instead of a service?

~~~
gitgud
That is an interesting _Hacker News_ type of phenomenon, but I personally
enjoy reading the alternative solutions to a presented problem.

And sometimes it turns out that the SASS product is simply a wrapper around a
cli tool... for example the product [1] _Mole_ , which is a wrapper around ssh
to make it easier... but not really necessary...

[1]
[https://news.ycombinator.com/item?id=18236125](https://news.ycombinator.com/item?id=18236125)

------
fouc
It's interesting, a few months ago I asked HN about how websites can let users
maintain control of their own data, and I never heard of Edsu. This looks
pretty good!

~~~
syrrim
It launched a few days ago AFAICT.

------
pakastin
I don't get this, is the data stored client-side or server-side?

If it's client-side, why would I need a service provider:
[https://edclave.com/sign-up/](https://edclave.com/sign-up/)

~~~
heathjohns
It's stored on the server.

------
obituary_latte
Doesn’t save for me. After signing up and getting edclave address, signing in
an granting access, changing the text and reloading doesn’t save. Nor does
changing and navigating away and back - always get the “erase me..” text.

iOS safari

~~~
heathjohns
Sorry about that, and thanks for the bug report! I haven't been able to test
with an iOS device yet - I'll get on that.

------
blader_johny
Have you heard of Scuttlebutt?
[https://www.scuttlebutt.nz/](https://www.scuttlebutt.nz/) How does EDSU
compare?

~~~
heathjohns
Similar in that you get to keep your own data.

Different in that it's lower level - it's not a social networking protocol -
it's something you can build a social networking protocol _on_.

------
christefano
Oh the irony. I clicked through to edsu.org to learn more about the backend of
this note taking app, and the error I got was:

“Safari cannot open the connection because the network connection was lost.”

------
z3t4
I think edsu could be nice for "serverless" apps, eg static web apps. Should
make it work offline. And edsu should keep a copy of the data on the client.
Then sync once the client is online.

~~~
heathjohns
Edsu's data store is content-addressed - i.e. everything is hashed and
immutable from a storage perspective.

A great thing about this is it makes a lot of caching problems simply go away.
So while there's no explicit support for local caches disconnecting and then
re-connecting later, the underlying protocol gives any library wanting to
implement this feature a lot of support for it.

------
scottmf
A frozen banana that won’t make you sick and kill you!

------
beaconstudios
if this used gun.js, you wouldn't even need a third party provider.

(not affiliated with the gun.js team, just think it's a powerful P2P
platform).

------
Markoff
how goes it compare to Standard notes

------
svnpenn
doesnt work with private browsing...

~~~
nihil2501
like chrome incognito? i tried and it does

------
slantaclaus
Evernote

