Fluence Labs Community, 14 Oct 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Developer Community Call #3 - AquaVM: Empowering distributed systems

Description

AquaVM: Empowering distributed systems

00:00 Intro to the community call, agenda
02:03 AquaVM presentation intro
02:48 Aqua language& Aqua Intermediate Representation, AIR
03:46 Fluent-pad example of aqua function
06:35 Fluence language stack
08:19 Fluence network scheme

Aqua Intermediate Representation (AIR) foundations
09:07 AIR: operations
11:47 AIR: instructions
12:34 call
14:52 seq
15:02 par
15:33 lambdas
16:31 ap
17:10 xor
18:07 match/mismatch
18:37 fold
19:13 iteration
20:38 null (instruction for code generation)
20:50 AIR: particle

Implementation of AquaVM
21:50 Aqua inside the Fluence stack
22:20 AquaVM is a state transition function
23:14 Value types of AquaVM
22:56 Main principles
37:54 “Math” point of view to AquaVM
45:05 Conclusion
46:07 Useful links

Community Hacks
48:00 Joera Mulders
58:35 Juan Obligado

01:04:20 Discussion
01:14:04 Updates from the core team

Examples https://github.com/fluencelabs/fluent-pad/tree/aquamarine/client/aqua
Aqua in Browser https://fluence.dev/browser
Fluence documentation https://doc.fluence.dev/docs/
Discord Support https://fluence.chat/
Telegram https://t.me/fluencedev
GitHub https://github.com/fluencelabs
Join Fluence Labs https://fluence.network/join.html
Community Calls wiki https://www.notion.so/fluencenetwork/Fluence-Developer-Community-Calls-2733beddb3ff4e4986c4fcc830fc796d
Fluence Developer Updates https://t.me/fluencedev

A

Yep, so this is uh this: is the notion page we're using centralized notion page to run these decentralized uh community calls. So um today is: uh is a community called number three uh which should be about aqua vm? So before we had fluency.

B

A

uh We actually, I can even see some some slides I can like we. I think we will. We will share this page, so you can find slides from the previous uh calls and uh also recording of the previous calls, I think on youtube.

A

So um I think today the plan is to uh the mic mike uh doing presentation about aqua vm, a virtual machine that runs aqua and dmitry talked about aqua last time uh and as usual, we're gonna have some um q a like any any questions and stuff uh from people um and we're gonna have um one and euro. If I pronounce your names correct uh presenting uh their projects, um so that's gonna be interesting and cool, so yeah.

A

um If anyone has anything uh feel free to uh till now or mike also like otherwise mike can start his presentation about aquarium hi guys. Can you hear me.

C

Yes, great, thank you, so I will share my screen.

C

uh So my name is mike, and I am doing engineering for fluid swaps, and today, I'm going to tell you about aqua, vm aqua vm is like our way to empower uh distributed systems, and please, if you have any questions, please ask you in chat or just zoom wherever you want, and I will try to grab them at the end of the section and answer them all. Also at the end, we will have a short or not short, q, a section depending on the time.

C

uh So, let's start akuvium is, as I already said, is like the thing that could be considered as the heart of the fluence network. It made complex to allow all other parts to be simple and but before we could uh start to discuss aquarium itself.

C

Let's briefly, uh would briefly uh like consider aqua again, so dimitri uh has so literally covered a lot of topics about aquaman previous community call, but uh now I want just to show for those who not attended on previous time- or just I know, forgot what is aqua and why like, and how accordion connected with aqua. So aqua is our new uh language. That, like is intended to run a complex multi-agent scenarios across the network, uh especially p2p networks, and on the slide you could see so guys. Can you hear my uh like my mouse?

C

I can see it.

A

But you can't hear it, you can see it, but we can't hear it.

C

Yes, uh okay on the left box, we could see simple function uh that handles user joining in written on aqua. So this function is a part of our simple messaging system called flintspot messaging application, and this function so the main the function responsible to call userlist.join function. So imagine that there is some some user structure.

C

It doesn't matter how its look likes exactly and some global app config and the subconfigure is a user released service with that's identified by peer id and with such an operator it allows to call uh a service located by uh search, p, ready and service with such service id that was so unified on the first line and I'll find on the fifth line, so user released this code and the result obtained from is released and returned by by this function, and the result here is just a simple structure that contains two fields on the next slide.

C

You could see a more complex example of a function also from this service from this application. Sorry service is a different thing. Now that thinking, I would network- and this function is intended to post message into this chat application, and here we could see that it works with two services. The first one is authentication service and second one is the history service. So, first of all, this function obtains a result from the authentication service and then passes to service code, history and history.

C

Services, simple service, that based on sqlite, that comparative webassembly, and it just adds some entry to some database. It doesn't matter and uses. This is authenticated flag to like uh to make sure that the score is authenticated, and it should really add this entry to the scale database and all other lines from uh seventh to the end of the function.

C

They are intended to notify all users that are obtained through this list through this function sorry get user released. It also doesn't matter how it works, but uh so, let's uh imagine that that return array of user uh of users.

C

That, actually is it's a pure id of peers in our network and then adjust in parallel that it's important, just in parallel, send notification to all these users, and this one is called back on typescript on a browser and also the result of history services returned without here. It's also the simple structure, uh that's comprised of three fields and the full example of if you're interested could be found by this link at the bottom of the slide.

C

So uh like why I have thought about aqua, uh but like uh today our theme is akoviem, so actually we have like a complex language stack and to execute aqua. uh We have our own intermediate presentation, called ear, aquamarine intermediate presentation and we have a compiler written on scala that allows you to compile aqua code to air a representation, and we have aqua vm that actually interprets this here scripts and this aquarium is written on rust, compiled webassembly and thanks due to that it could be run actually in marine boston, marine and in a browser.

C

Marine is our general purpose. One time that I will cover uh on the next community call so aquarium is just interpreter. It interprets instruction by instruction, if you look out how it goes on on next slides and aqua. Compiler has several targets. First, one is to execute error, scripts and so sorry to produce air scripts directly and second one is to produce both air scripts and typescript code so to to make it possible to run in browser or node.js uh and on the slide you can see the scheme.

C

How, uh like fluence network, could be considered so heroes right, a bunch of nodes and relays. So actually each node could be relay. It's uh like it's, not a dedicated role, no network, and there are two clients that, like uh here it's represented by browser uh and on each of these actors and network. There is the aqua vm, that's identified by this echo marine sign um so, and the using rust and the compiling toolbox assembly allow us to run at both uh on clients and on nodes, so in all peers in our network.

C

uh Okay, uh we will like cover introduction and uh let's take a look, how airworks likes um so actually, air scripts and air itself is based on picalcos.

C

So picalcos is a special type of calculus that intended to describe some distributed systems, and actually you know so there are a lot of theory under the hood. I mean a lot of theory of the calculus, and here you could see some extras extracts of the theory and some basics uh operators, some basic uh like uh actions and combinators and picalcos, for example, on the first line. You could see that, like this uh exclamation mark and this question mark, they represent like ability to pass a channel to other channel or past name.

C

It could be say it's differs from paper to paper, but let's call it the names. So here, for example, names could be passed to others or other names and like received from other names.

C

um Also so picalco's is about process is about process. Communication. Actually, calculus is based on process calculus. These are several important features and on second line you could see how process could be uh combined to each other. So the first one means that so this dot means that this process could be executed. Sequentially so one after uh other.

C

This one plus sign represents some undeterministic choice, so either p or q. Will be executed and the uh the last the last one represents like ability to uh start processes in parallel, and so also much in mismatch is also presentable in because and also the last thing that I should cover here is replication, so replication is a way to represent some some oops in picas, for example, or some recursive functions, or something like that.

C

So, for example, you know that lambda calculus could be translated to p calculus and some fixed point combinators could be represented through replication in pikachus, but replication is a bit, uh is a bit more complex than lambda can cause uh okay, let's move on and uh see uh like how all previous uh all previous features of picalco's allow us to invent air. So here you could see all structures that air consist of uh like.

C

There are not so much of them uh and almost all of them are inspired by by picaicos except the last one called up and all of them we will cover on next slides.

C

uh So probably I need to see here that fault also, you could think about it as a about four loop uh is inspired directly by replication. So all one, I think, uh the obvious. uh So let's start with the co instruction, so construction um they're intended to call functions uh from services. So now it doesn't matter what the service this we will talk about services uh on the in the next community call, but by services now we could consider um webassembly modules.

C

So by such instruction we could call web assembly module uh all instructions. uh So now here has only text representation that is based on s, expressions that are inspired by webassembly text format, and this call consists of several parts. The first one is triplet, so this this one is intended to um like set the location.

C

So, first of all it's uh so this one is specified where um on each on which pill on in the network uh which service should be called and from the service which function should be called so remember, aqua aquacode that I showed previously and then, for example, how user released service code. So this call his release could be directly compiled into this call. So here could be like user release peer id. This is released service id and a function join so and into this function.

C

uh It's possible to pass arguments.

C

So like any any set of arguments and also function could return a value that will bind to some names that, like uh should be the last name in the in the whole construction and uh like a row. It looks like this and uh from uh I know, from from a usual scripts and language perspective, it could be considered as a like uh calling uh like function put from a dht service and obtain result into some data.

C

So what is data is doesn't matter now? uh I will tell you next slides. uh Okay, the next instruction is uh siku, so siku is a very simple one. It takes two instruction and executes them sequentially, so oreo is also a simple one. It also takes to instruction and executes them in parallel.

C

So what does it mean sequentially in a parallel? It's uh it's a bit unusual. It uh not so parallel here doesn't mean that, like this services could be caught in different threats or some I know in asynchronous manner, but uh like we will like also cover this topic next slides and also it's possible to uh write some lambdas to access different, uh different fields into a value so value in our uh so in our scripts. They are json based so, for example, this one.

C

So this is lambda this one that allows you to, for example, imagine that in the script we obtain users from some user list. Endless users is a json array that consists of json objects. That has such fields such as your name like p reading, name and so on, and this one there allow you to choose the first object from this list and from the subject choose like value and it's fine by such name such field name.

C

Now, it's rather simple and up as it like was introduced uh by us to like not call uh web assembly services each time but allowed to made some make some complex way somewhere. Sorry, some story. Oh sorry, some simple example in the era: script itself, so, for example, here up allows you to like choose uh from this array, is the first element then pure id and set it in a field called user zero.

C

So just application allows you to apply swamp, but imagine that, for example, in this race there is no uh the first field. Yes, it's it's imagine that it's empty. So, in this case, if it's color, so all streams are possible. If it scales discover there will be exception and this exception could be catched by sword instruction and, for example, here we could write such a script that sent error to some uh like init period. Priority here is a uh is a constant yes it so it's this constant.

C

Allow so represents uh p radius, who sends the scripts, and the last error is also a constant that represents object uh that was last year or so, for example, accessing to the non-present element in the scalar and also like not so, it's also possible to check size of users by applying lambdas and so to check it against something. There is a. There are two instructions matched and mismatched.

C

They also directly come from the calculus. So a mismatch takes two values and like in comparison for equality.

C

So a more complex instruction is a fault, so fault allows you to do. Iteration fault has uh like so it iterates through some iterable that should be array or stream, and it sudden this like the next value in some iterator. So it's the second argument of fault instruction itself, and it executes this instruction. This uh and inside this instruction, it's possible to like obtain values from this iterator uh and see it by example. So imagine our previous, like uh previous service code, is released.

C

That provides you like users in such a form as its array of json objects and the first instruction by user users and set them into users variable and then fold allows you to iterate through, for example. So this uh users is a json object that contains users, yes, and we use lambda to access this users, and each next user will be set into this iterator, and you could use this iterator in everywhere.

C

In the instruction inside fold, for example, we could use it to obtain p radius from all these users and, to I know, to call some display message display function, and this instruction is intended to I like uh to set iterator to the new element, and if it's, if there are no any elements, it will pass the cycle so just triggers an acceleration.

C

So now is imported instruction, really important selection for code generation, so it does nothing. It takes no arguments it just null. um Okay, it's all about instructions and the take. Let's take a look to a particle. So particle is a core of our programming module.

C

You could see the structure of particle on the right side, and here there are three important fields uh for uh aqua vm. It's scripts. You need pure id and data. So script is just a string representation of error script. Initial id is a priority of peer who immediately initiated who sent the script for the first time, and data is a special one. So we will talk a lot about data in the next section and the particles they like there.

C

They travel from peer-to-peer and they collect collect data that obtained from interpreter from aqua vm to like send it to the next aqua vm. Okay, let's uh talk a bit how aquarium is implemented and what is data itself? So on the side, you could see uh like pictures that I really love the script. This picture represents several layers in the fluency network, especially two of them execution, wear and a composition, layer and aqua vm here on each pier.

C

So it's inside marine and aquavium from some formal point of view, it could be considered as a state transition function where state is data, so if you use both state and data, this is the same term. uh So aqua vm takes two data.

C

I will call them the first. One is previous data. Second, one is current data, so they take two data, one of them current data imaging that they just come from a network. So just come from particle, so I mean it's this one, this data and it produces a new data and a list of peer uh where host or peer who run aqua vm should send this new data.

C

So it's just a finished state machine. um Okay, as I say uh said, we have two types of values. The first one are rather simple: they are scalars. They are fully consistent. They are based on a json. uh We will like so jason. Now uh I consider it as a probably a good way to start. uh Probably we will change this uh format in the future, but not now, and uh they are consistent.

C

It means that there is a same on the uh each pure network for each particle, so in in in term of one script, they're uh the same on each period and uh because of that they could be an argument of any instruction any of instructions that I that we will cover and the streams are rather complex.

C

They first of all start dt-like. They are locally consistent. uh It means that on each peer, they're they're consistent, they are ser dt, but they could differ from peer-to-peer.

C

So I mean that, for example, on one peer stream, food contains the same values but in different order, but this order keeps keeping every time uh when, like new iteration of interpreter camps but like on the different peers, they could differ. They depend on a uh on a script on a network on some time in timing and networks, and so on.

C

They have versions in the code. They call generations, they could be clinicalized by clinicalization. Here I mean that they could be trans, they could be um transfers to a scalar domain they could be. uh I know they from some special instructions that we're now in the work in progress uh stage. They could be from stream. We could make a scour, and after that the stream became uh consistent in a network, but without clinicalization they could be used only by a few instruction.

C

First of it of them is fault, so fault could iterate through a stream and the fault internally, uh like it's really complex, so it conflicts when it raids through stream, because it should be deterministic for each time for each run and also string could be used inside up as a second instruction. In up so, for example, we could add to throw up a value to a stream.

C

So, okay, let's see how instructions are handled by aqua, vm, so actually aquarium. uh Three construction is a router directed graph. I think it's obvious so, for example, imagine that we have two, uh so we have like par these two calls and from uh accordion perspective perspective, it would be just a graph with three uh edges uh and, let's consider a complex, more complex example. This fault- and here you can see also more complex graph that have a cycle, so this next produces a cycle from next to fault um and also like instruction could be.

C

So it's not a binary graph. Yes, because here we have fault, for example, that or a match in mismatch that has only one uh child not to child, but all other instructions except co, or now they are binary.

C

It means that they takes two two instructions.

C

Okay and the from uh like cod perspective, uh so the instructions um like based on a visitor pattern and they just executed like as a tree.

C

um Okay, let's talk a bit about what parallels and sequentially uh means that I announced on previous slides uh so on. Each execution, aqua vm, tries to cover all so as much uh as much vertices and graph as possible, uh and during this execution, sequence or and par like has different, have different rules to execute so for the siku.

C

The right subtree should be executed only after the left. Sorry sub sub graph of the after row after left sub graph completed. So it means that all co into the left, sub graph should be uh should be called, should be completed without any exceptions.

C

uh Fox4 the right sub graph will be executed only if webster graph failed with the sum exception and the par always execute both subgraphs, not depending on errors, completeness of calls and so on. So so parse parallels here means that parts will always execute both uh both childs okay.

C

Let's consider what does it mean to execute um so, first of all, we don't have any saved entry point and each time for each start, execution start from the very beginning of the script and like in this case we could execute some calls several times and to not to execute.

C

We have execution trace, they stored inside data and they like they follow this graph approach, but this is could be construed as a like linearized graph and from this box you could see that we track several instructions, so bar call fault and up for this instruction and for fault here, if photo trades only through stream.

C

For this instruction, we have evidence in the internet race. Yes, in the data we have a state for them and, for example, here on the right side, you can see how state for par looks like so just two values, uh size of the left, sub-graph and right, sub-graph and for call result is genome uh that represent three states of call, so first of all call could be uh could be like requested, so request could be sent by some peer and network and then uh like interpreter obtaining such a state.

C

During execution, it understands that it shouldn't, uh like really imp so causes call yes, because uh this was already called by someone uh except one situation when, for example, imagine that the score was uh so this particle could be sent to a interpreter that could really call uh this uh call co-instruction, because pure id are the same yes. So the interpreter that runs on a some peer has the same periodization.

C

And its first argument of the construction, so in this case it will be executed. Also call could be executed so and here will be a value, so the resulted value and finally call could be failed, and here we could see that some, uh like exception formation, is also stored inside data.

C

And like, but how cooling a co-instruction looks like actually, aqua vm could be considered as a pure function. There are no any imports to appear and like but aquarium during the obtaining during the execution of instruction.

C

They see whether it's possible to uh call this like this to handle this call on the current period, if it possible, for example, like cisco or this one, uh then it saves all uh parameters. Co parameters, all these ones, so arguments uh service, id function, name and tetraplate so that our platform won't cover but like they also be tracked, and it's safe collect them during the execution and then provided after the end of execution.

C

I as a call requests and then after some moments or it doesn't matter when then aquarium, expects call results so where there will be results of execution of the score requests and like. Actually, there are two reasons to run acrovm again and again. So first is uh handling a new data from a new particle that comes from a network, a sec and a second reason is to handle echo result from some service, also so from web assembly uh service, and this scheme has several advantages.

C

First, one is like interpreter now, so interpreter is a pure function and easy to maintain uh it's easy to have. I know uh same binary, boston browser in in on a note, and also it allows to asynchronous and parallel execution on appear.

C

Actually, it's a pure, uh it's a pure duty to decide how services should be called so peer has a lot of freedom in this question and the actually execution of aquarium takes a fixed time, comparing to, for example, having an import function that could call uh services uh like one by one, yes and uh not not in an asynchronous manner. It was our previous incarnation of aquarium, but now it's fully asynchronous with a pure function and the scheme has a lot of benefits, and probably it has only one disadvantage.

C

It's some overhead because, like running for each core result, um it takes like some time for script, parsing and so on for that immersion, but uh this also could be optimized because core results could be sent to aquarium like in in a batch mode.

C

uh Okay and let's finally, take a look, how actually constructions uh are handled. So there are two situations where the spear id they are equal to pure id of a host for interpreter is like launch or not equal. If attackful then interprets as an interpreter or aquarium collects all these parameters like service name, function, arguments and tetrapletes and return it after the execution, if not equal, then um if this execution will uh like won't, execute it, so it is uh hasn't been executed.

C

Already uh then, like next peer ids is updated with this pure ide and a host should send data to the spear ide. Then after the execution of aquarium.

C

Also, probably the main the most complex part here is the merging of current and previous data that are passed to the passes to aquarium and why it's so complex on the side, you could see some uh like some imaginary situation. Fun, for example, previous data has the following form. So please take a look to the this par instruction.

C

So remember. I have shown that power instruction in in the data consists of two fields, size of the left, the sub graph and the right sub graph, and here so, let's imagine that the size is one and one. So here it means that um on the left sub graph of previous data, there is one instruction on the right, also one, but when new current data comes uh then like the situation on the current date is different.

C

So, on the on the left side, both in one instruction on the right side, there are six instructions, and imagine also that there are additionally two calls that, like after merging this new oss, current and previous data could be called during execution on the sphere, because data data emerged and the execution on a graph passed to a moment where the score could be called uh and the result of data that would be produced by the interpreter. Would look.

C

Spikes like this, so par is instruction that, like cares about sizes of its subgraph, and this subgraph could be could be longer than before, like before run.

C

Okay, and also there are, uh there, is also a complex example of this fault, but fault is much more complex than par. It won't be so I think it's won't be covered today. But if you have any question, please ask them I could like.

C

I could tell you on the q a section, so this one is only for handling power and a call so and on the like, as the last slides, let's consider some uh mass yes mass point of view on the aqua vm. So from uh the mouse point of view, aquarium could be considered as a like closed function because it's functioning. uh I here means that these functions that have co-domain co-domain.

C

That is a product of two uh two sets and the result is also set and the oh, so oh value, o domain and co domain. Only these two sets uh in like a following key: it's called magma, so it's just a function in a set that where function is caused- and actually it like like this set like where x is data, so uh data so interpreter takes uh current and previous data and producing new data.

C

It also actually takes a lot of other arguments, but they're not so interested, not so interesting here in in this context, because actually, according to this set this and this function, this uh like saturn function, actually there it's semonite, so monoit is a algebraic structure that has several properties first, one is it associative and the second one is. It has neutral natural element, so it has element. So here it's empty data and this element uh like applying it to the data, produces the same value.

C

As the second argument, I will show next slides why all of these properties are mothers now, please just take a look on all of them and the third and fourth uh options are not about monoid, but they makes the third one makes monolith non-commutative, because it's important in which order data are passed and like new data, so actually interpreter is a status uh and it saves all data in or sorry it says it saves all state inside data that it produces as a result, and then this data should be passed uh as a previous data, and the last options is to input in the patents properties.

C

um So, okay, let's probably see how like why it's important, so the first one is a property of uh that f is a closed with respect. To set x where x is all possible dates. Yes, data that consists of our all combination of our four uh enums. Yes, four uh variants of enum, so this property guarantees that aquavium, like always return uh data. If aquarium is not like malicious, it's not normal format, then it always return a valid data, for example.

C

If um so for this code, you could see that if some malicious data are passed to the interpreter, for example, data that couldn't be serialized, then as a result, there could be a previous data itself that won't be merged with this malicious one and if any error are produced during the execution. If, for example, uh current data are parsed successfully, then also uh like valid data will be returned in any case, the second option is uh really important.

C

It's important because it allows fork joint scheme in network, so this option that allows you to merge data in different order in different order and obtain the same result.

C

For example, it allows you to make such complex faults because fault, especially if it parallel. So sorry here is siku, but let's imagine this is parallel and if fault is parallel, then the result of the stream.

C

As I already said, they could be differ on different peers, but on one pier following this property, it guarantees to be guaranteed to be consistent because it doesn't matter in which order particle you come to appear by this property, as a result will be the same so like whether it come for example, uh the result of I know from uh some pure d0 or pure id. First, uh it doesn't matter the the result will be the same.

C

The third one property uh there could be used to, uh like so immediate, uh remember the scheme where interpreter collects, parameters of calls and produces as call requests and then code results should be passed to uh aqua, vm like to to set uh to like to re-execute calls as co-instructions.

C

uh So, according to this property, uh we shouldn't pass again and again current data. Yes, we could pass just empty data and nothing would be changed in terms of previous data. So yes, there is some natural element that here represents us just empty data and the only work uh and the last option is the option of non-commutative.

C

So actually uh aquavium is status. Yes, as I already said, and it keeps all the state in the into data, yes into this data that provided by aqua vm and this data should be passed then, on each new particle that come from a network, it should be passed as a previous one. So it's uh uh it should be like implemented by a host that runs that this aqua vm and it's important that this new, this data should be previous one.

C

So all these options uh allow us to so because aqua vm is rather complex. uh All these algebraic properties allow us to think uh about some guarantees that aquarium provides and uh like about to uh implement host. That runs a career in such a way that all these guarantees, like will hold uh okay.

C

So today uh we covered actually uh like a lot of part of of aquarium, but not all uh we haven't covered, probably the most uh complex part about merging data and, like probably we'll cover on next committee, calls, but not today, because it's really complex and like. I won't finish my talk today that I just say that um aquarium is like the reset heart of the fluency network and it allows you to run air scripts from that compiled from by aqua compiler and on the next community call.

C

I will present marine our general purpose on time that allows you to run aquavium on these services with webassembly services on a node and all these projects aquavium and aqua they're, open sourced. You could find them by this link and actually, if you are interested in fluence, we have several sources of updates so, first of all twitter, then we have newsletter and the channel in telegram and discord with our developer updates. So any if you have any questions, please contact me by email or issues in repositories or somehow.

C

So. Thank you very much. I'm all and waiting for your questions.

A

I think we are a bit limited in time, so.

A

So maybe like, if there are questions, feel free to interrupt me. If there is no questions right now feel free to reach out to mike in any channels.

A

Sorry, I just needed you some noise, um but actually actually I I just wanted to to say that, uh like uh guys, feel free to jump on and present your projects.

D

um Shall I go first? uh When do you want to go first?

D

Okay, uh sorry, my name is matt. I was first on the list, so I was like in my mind, I've been like already anyway. um My name is yura, I'm a developer from amsterdam.

D

uh Normally I do like websites for editorial teams and dashboards with the data, so I'm also more of a front-end guy than back end and all these formulas that we just saw. I was that make me like lose my mind anyway, but so, when I think about this new generation of technology- and I think about my websites and my dashboards, I think about how can you have uh websites with a static site generator? That is completely like decentralized, where no person can touch it, and how can I have for my dashboards?

D

How can I have information flows of data that are not touched by any human being and they live on these? What computation layers that fluence is one of them um so for the hackathon that we just I just participated in, I tried the following, and I didn't now, I'm going to look for.

D

Oh, um I think I need to share my screen. Are we prepared to do that.

A

You should be able to do that.

D

And share screen at first okay.

D

Are you seeing my screen?

D

D

Okay, um so um I was trying to make um a a data pipeline that gets data from the blockchain and posts it on ipvs, and this is and I've used fluence for that and I was in the beginning. I was trying to see how far I could get and I got it working in the end, which was a surprise to me and I'm very happy and very positive about it.

D

But at the moment it's not working anymore, because I started changing things and everything, so I can't demo it, um but this is what I did is that so um basically everything I had to do was uh I did very little aqua, but mostly marine, so I made all like little surfaces that did part of the data pipeline.

D

So in the beginning, I have to listen to events on the blockchain, uh and uh so there is like a a function to call the e filter and it just checks like every minute see if the event on that specific contract has gone off and when it does, then it gets the id.

D

And with that id I can go to a sub graph from the graph.

D

Like like this one, well, you see, for example, I get 18 back and then I can get the data from the contract. Like this data, I get back.

D

And then I I put them in a tree on the ipfs, and so that means like the it's like a um you, make a new uh dark notes, but you also put the notes into the array of its parent and of that parent, and so you so you have like a tree and the top of the tree.

D

D

So this is all I'm doing with like the creating the new leaves and storing the cid of the new leaf into their parents, and then in the end I get basically the the ipfs cid of the uh the root of the tree, and I'm storing that on. I dns.

D

So that's about.

D

Here so I have my domain name called public.

D

That's this one, so this is basically the current.

D

And over here and then.

D

um And- and this basically is all done with fluence uh different um marine uh service, so I have like here: what do I have um an ens surface so that talks through this is listing the theory events and the graphql servers that does the stuff with the graphql, and these are blubber, so they're all little services and they work together with the aqua.

D

So this is one where.

D

I'm doing I basically just have a sequence of services running or what I do is the the wasn't file of the service is on ipfs. So then, first.

D

First, I get that and then I deploy it. Then I run the functions and so on and so on and in the end I clean them all up again. I just remove the surfaces again.

D

um So that's very simple in comparison to what was being discussed before, uh but it's been working and uh uh that's uh I like that very much um yeah, that's about it.

D

One thing I've been doing this week is that um I I had one problem with the fact that when I'm talking to the ens, uh I'm making a raw transaction call to the blockchain, and I need a private keypad and uh previously.

D

Which is except for stupid, also not future proof. So now I'm trying to make this sort of uh surface that uh creates a private key and an ethereum address, and then it keeps that in memory- and I use that cert and it also has a sign method. So I'm you I'm going I'm first preparing the transaction. Then I'm going to the service that has it's uh as the private key install in memory and signs the the transaction and then it goes back to another surface and then it makes the call.

D

And it seems to be going to work.

D

D

A

Sounds amazing.

D

It's very pro oriented and.

D

It's mostly been trying to learn how rust works and what you can, how how to what sort of libraries you can use with rust uh that compile to wash them, and you know, and and then using the curl adapter from the marine from from the fluence people uh to um to make this very simple calls to the blockchain um and uh but that it works and uh yeah I'm gonna keep trying it it's.

D

It's also very I'm trying to figure out how how to organize the flower in, in a way that I I I can have something I would have had something today that I could actually demo.

D

Instead of saying I changed things and I don't know if it's working, but it's very new to me, so I'm confident that it will become better.

A

I love the uh the services architecture like how you organize it just as a different services.

A

So, basically, um if there will be the service discovery way to like uh you know, discover service by just the type of interface um that you need, you will be able to just you know, use aqua to discover them instead of uh implementing them and other people could uh potentially, if they, if there existing, ipfs and they're retrievable. So other people could um just take and reuse these services across the network, which is super cool.

D

Yeah, so I'm trying to make them more generic every time I'm looking at them um now. They've been very specific for this use case, but um eventually there will be surfaces that are very generic and reusable, and then people can just start piecing them together. Yeah.

E

Yeah awesome: okay, it's my turn. Now: good luck, okay, okay! That was amazing.

D

So I stopped sharing yeah okay.

E

I'm sharing now, I think so: okay, okay, perfect.

F

Yeah, unfortunately, I will not be able to demo as well. I had a demo but suddenly stopped working with the latest version. I had to upgrade my environment that new version of the node is like not I've been able to connect, but I'm not even being able to send the messages.

F

uh My name is juan obligado. What I did create on hack fs was a price aggregator, uh which process processes prices from well any source. Right now, in the demo, we were like uh inputting those prices manually and I writing those prices into ceramic uh ceramic then stores the the stream of prices into ipfs.

F

So I will need to go to the code as well. Sorry for that, uh so I I do have my set two thing. Two things one is my uh adapter to ceramic, which basically it's similar to the url adapter that the there is in the in the example uh and instead of calling cool it calls a ceramic client reason, for that is that uh I didn't have enough time for actually creating a native uh ceramic client rust. uh That's it's something else I would definitely would like to do, but able to do it. Yet.

F

It's just having a lot of stuff to do so. We do have this ceramic adapter, which basically encapsulates what the ceramic.

F

Oh uh yeah, the ceramic uh client util, which is called ceramic spray, is just the command for for doing stuff with ceramics, so you can actually push data into a stream with that, and also we do have the aggregator itself, which is an aggregator service which basically do have two methods. One for retrieving data with the data have the thicker of the price of the high loan, close the duration of the bars that we're going to have and start time when it was last updated.

F

So what this this code does is basically, when it receive receives a new price uh checks, updates the open, high low close and creates a new wire if needed, okay, um so far, so good, maybe sorry, if I'm going too fast, please let me know.

F

So here in the demo that this was supposed to well check the service but and then reading the the price from the bar uh historical prices and then being able to update them and show it so show them here, but yeah, as I mentioned.

F

Unfortunately, weren't able to make this work again.

F

Well, comments about the technology: it's pretty amazing. What you're doing it's just it's! It's amazing the pace. I think this was like one month ago and the the whole api changes changed completely in that period of time. So um that was pretty interesting. The pace is going it's kind of difficult to keep with the pace uh and the app.

F

But what wanted to this is more like sharing thoughts and experiences that actually make in the presentation so important.

B

I think it's it's great, it's great one that you're sharing. You know uh it's important for us to hear what are the processes? You know what what were the ideas and, of course, it's like uh natural. That code is changing a lot and very rapidly. So it's it's totally. Fine, don't worry! Thank you. Thank you for the presentation.

G

B

H

E

H

Ceramic integration: there was a a bug in ceramic uh that we have just fixed in uh like while preparing for the ceramic workshop a couple of minutes ago. So we faced.

B

The same issue.

H

That you did yesterday and spent the whole day today fixing it. So it's absolutely not your fault and you're. Welcome to the workshop right now.

I

Okay, thank you very much I'll I'll I'll. Send you the details. One uh okay, I'm gonna probably did so yeah.

F

B

I think it's in an hour right. The workshop.

B

Like I can send the link to, and actually we have it in uh in the notion they link to the workshop today if anybody wants to chat.

C

Guys may ask you a question like um you have for like touched marine touched, aqua and all other stuff. uh Have you faced any important issues and pro or limitations with maureen with aqua and like do we have something to? I know, to make experience much more easier for developers well,.

F

It's probably that the stock is pretty big, the amount of stuff that you need you need to put in. It was kind of difficult to, like put it all together, but that was mostly me. My fault, like lack of knowledge, uh so the it's a little a little bit hype to just get going, because you need to put rust you need to put javascript, then you need to set up like the the notes. If you, the notes, are very basic.

F

So if you want to do uh complex stuff, you you need to play with your own notes, and that might not be that easily available. So you it would be great. For example, if there were some kind of on the premises note that, where you can play with that.

F

uh But I I don't know how maybe that's not too big.

D

uh My experience is very similar um and it's very uh there's so many it's it's very, very complex in a way, and I I I don't need all the the complex peer-to-peers stuff. I just had an idea of what I wanted to do and just have to think of like what's going.

D

What is the next step and just only ask questions about what my next step was, and I had great answers always in the chat on the telegram and um so yeah, I'm just discreet um what my next step is and uh because, if I start trying to understand everything, uh then I'm gonna get lost yeah exactly something like that we find.

D

But but what interested me about the uh uh the talk uh uh and what I haven't figured out is the the particles and and then like how in my workflow, can I actually um lock or see what's in them, basically because I'm probably using them. Although I don't know, I am um you understand where I'm going, um because I I need. I need to see like an object that I'm logging for me, so it can exist in my mind,.

C

You mean that you want to, uh for, for the network to be more transparent.

D

um It could be that I I just haven't discovered the function of how to do it, um so I mean I've. I've been looking I've. I've had the the the log open you know of I. I always worked a local mode and I had the the logs open um and so then I could like puzzle out what was going on, but but to um to understand what the data is on on the particle um that that has not been uh visible to me.

D

C

um In the meeting, please correct me if I'm wrong but uh like when we when we designed. uh Oh all this, we don't have in mind that user should touch particle itself.

B

C

J

C

Just should be, I know it's a as easy as well.

D

Cytochromes are also way too small to touch.

H

Well, the particle data structure is a very, very complicated and hard to analyze as it's made for machines, and we are trying to make it more and more tight, but actually I think that it totally makes sense to visualize what services were already called and what data was returned.

H

So if we have this information, that's uh that could could make the basic element ready for particle execution, and maybe we need some something like I don't know, um react tooling, or something like that or a websocket visualization. When you just can see uh what.

B

H

B

D

H

uh Yeah thanks.

D

So much for some kind of profiling.

F

For example, or something to easily show uh what's going on.

D

H

Yeah makes sense.

D

The example with authentication, then at a certain point, you can call a method and it says like uh uh in its peer id, it says uh particle id. It says it gives a couple of um properties that are connected to the is: does that come from the particle.

H

Yep from from the uh from the surface, you have access to all the fields, all the immutable fields of the particle, or you can't have this access.

H

It might be not provided, but there's an implementation detail if it's needed it can be done so from from the service, you can access and you can know the current peer id, which is the host id where the service is hosted. You know the service id, you know the init be ready and for each argument you have this security droplet with the the sources of data that comes from the the aqua vm.

D

Yeah, so I'm when I'm just when I lock those things and I can look at them, then I I get a better understanding already when I just start um just start thinking about it and start looking at it.

H

Should we describe uh somewhere uh the particle and data or or what you actually need? Is uh this tooling to visualize the data.

D

um Well, I I don't see the the uh the tooling, uh uh uh you gave an example, uh but I didn't. I don't know how that works, so I I don't see them from I. I have no visual uh idea of what you're.

D

H

D

H

Very similar to the example.

H

Like you can open the network tab and see the messages flying here and there.

H

And for the particle, uh it's more like the web socket or something like that, where you have the resource with many messages inside.

D

Okay, yeah yeah, but that's that's convenient for people that that have a front end.

H

D

Yeah, I'm not using the front end.

H

And without the front end, and it would be even better- we could provide a similar cli experience with a yeah. I.

B

Think we need to.

H

Design some some tool to help uh understanding. What's going on with particles.

H

Not sure what exactly, but we will have it.

F

Yeah I I saw that there is a book, maybe in case in that book would be awesome, because all the the stuff that we have in this uh talk is the first time that I actually saw that much information about how the vm works.

F

Maybe updating the book there. There is the aqua book with with all that would be awesome.

H

Make sense thanks real prairie, guys.

D

I've already started preparing for something I asked.

A

A

I think we are out of time already, but uh if anyone uh has any topic, uh any other topics to discuss or any input feel free to share. uh Otherwise I think we are very good.

G

We wanted to share some updates on the last time.

A

Surely yeah, let's do it.

G

So, let's start from my part um in we in the marine stack in the test sdk and in the last months we updated the marine test macro. We slightly changed its interface, so it's more clean and logic and user friendly, and also we had that ability to use this marker with several services at once.

G

So we can test services. Integration pass data from one service to another and we want to make more improvements later.

C

You can find examples in the design announcement channel.

H

Every short link to the announcements channel does any everyone know where it is.

B

We did and we will share them here.

A

Cool um nice, so the next, uh the next goal in two weeks and the next call gonna be about what about what about maureen, okay, yeah next time, maureen. um So we're trying to to to make these calls educational, but if they are too boring. Let us know we'll just talk with each other more and let's talk about the the complex stuff.

A

um Great thanks, everyone hey! Thank you very much.

H

F

Guys, thank you for joining.

G

H

Was awesome, bye, bye,.