Show HN: Share compute functions while hiding the implementation | Hacker News Reader

Show HN: Share compute functions while hiding the implementation

github.com

4 pointsogarten7 comments

TL;DR: We take the pain away from remote procedure calls.

Hi,

We are Christoph and Orell from Germany. We made LMRTFY (https://lmrt.fyi), a tool to share compute functions running anywhere with others without sharing your code.

In engineering sharing algorithms is often done via source code which is cumbersome if you need special resource (GPU, propietary data sets, …) and impossible if you need to protect your IP.

We created a a open-core platform to share functions bound to specific resources without sharing the actual implementation. Shared functions can be called from your code. Just like any regular function.

Find the open source tool on GitHub (https://github.com/lmrtfy/lmrtfy) or dive right into the docs (https://docs.lmrt.fyi/latest/quickstart).

Unfortunately, we need to require you to sign up because otherwise our servers would be vulnerable and we couldn’t make sure that only you can access your function (E-mail verification is not enforced right now). Alternatively, you can use social logins (google, GitHub).

If you like this project, please star us on GitHub!

We are very thankful for any feedback! Don’t hold back :)

Open articleView on HN

This seems to be exactly the SaaSS that the FSF warns us about: https://www.gnu.org/philosophy/who-does-that-server-really-s...

Nobody should use it unless it's modified to share all of the code with anyone who uses it.

That's a rather inspiring article! Thanks for sharing.

Thanks for the article.

We do not want to prohibit sharing code. You can always share your code. We provide a way to make the functionality implemented in the code available to other without them having to setup their system (install libraries, manage dependencies, buying a GPU to run something, ...).

Not sharing code however is a relevant requirement for a lot of companies to protect IP which we are able to address.

> Not sharing code however is a relevant requirement for a lot of companies to protect IP which we are able to address.

But this is exactly the illegitimate use in question. You shouldn't be helping these companies to do those bad things.

I am a big fan of open source but it's not possible for everyone to disclose their code.

Sometimes special resources are needed to run an algorithm (GPU, FPGA, ...) that are not available to everyone. Sometimes code is core IP at a company and cannot just be shared freely.

Is there an article describing how does it work?

Not right now, but will be added soon.

Generally, there are three components

(1) a runner

This serves the function and waits for incoming jobs. There can be multiple runners serving the same function and they will get "load-balanced" in a round-robin way right now. Incoming jobs are received via a message queue the runner connects to. The load on the system is very small unless a job is processed.

(2) our server

This acts as a catalog for all functions that have been served. It also does the user and job management. When someone submits a job, the server also checks if the inputs and outputs work with the underlying function, e.g. same units, boundaries are checked if necessary, ...

(3) calling a function

Calling a function is really easy right now, if you use Python. You just import the catalog that is loaded from our server (2) and then you can call remote functions just like any regular functions. You can also share functions with others by providing an email that the invite is sent to.

(4) a web app

We also have a web app right now (https://app.lmrt.fyi) which lets you control the status of your jobs, your runners, ... The app needs a lot more polish to be really useful.

I hope this gives an overview of the architecture. If anything's unclear, please ask.

Reply on news.ycombinator.com