Fluence is an open application platforms, where apps can build on each other, share data and users. The platform is powered by a peer-to-peer computing protocol and the new programming language which radically simplifies the building and composing applications. Fluence is an open alternative to cloud platforms and proprietary APIs and our mission is to empower global collaboration and innovation.
Learn to overcome the limitations of client-server architecture and enable continued innovation of internet applications. Fluence moves authentication to the network protocol layer and allows the expression of complex distributed systems as language primitives, simplifying the creation of many web applications. The protocol components (FCE, DHT, TrustGraph, Consensus layer) combined together compose a unique developer experience expressed in Aquamarine, opening new distributed application architectures.
Building Open Applications with Fluence
| Title | |
|---|---|
| Aquamarine 101: basics & pi Open Applications Development Link to publication | |
| Aquamarine under the hood Open Applications Development Pre-print | |
| Building a front-end for a p2p app Open Applications Development Pre-print | |
| How to make a Service and distribute it with the Fluence network Open Applications Development Pre-print | |
| Intro talk: Open Applications Infrastructure Open Applications Development Link to publication |
Program of the tutorial
The tutorial consists of two parts: theoretical and practical. We will learn how to build and compose open applications with Fluence protocol and Aquamarine language.
Theoretical part
Intro talk: Open Applications Infrastructure.
Fluence is an open application platform powered by peer-to-peer computing protocol and a decentralized licensing system. Fluence enables developers to host applications in the decentralized network and collaborate on live applications, reusing components and data. The protocol creates an open marketplace of compute capacity, so availability and pricing are not controlled by a single company and instead are driven by competitive market forces.
Applications are faster to build, easier to integrate, and more secure due to the enhanced composability. Business logic is incorporated into data packets orchestrating the execution of distributed components. Just as code collaboration creates better products, composition via network protocol enables live apps to be forked, expanded, or re-arranged into new and enhanced user experiences.
Speaker: Evgeny Ponomarev; 20 min
Aquamarine 101: basics & pi
Aquamarine is the multi-process composition medium based on pi-calculus, designed for distributed applications/backends, both in private deployments and open networks. Aquamarine scripts define the topology of the execution (when and where to move control flow) and data dependency graph (what results and what arguments to pass where), essentially describing the composition of (micro)services, e.g. using one service’s output as another service’s input. The language primitives are based on pi-calculus operations describing certain topological effects and secured by cryptographic signatures of involved peers. The Aquamarine approach allows building distributed systems of any complexity, effectively expressing network behavior.
Speaker: Dmitry Kurinskiy; 20 min
Dedicated Q&A discussion/small break; 5-10min.
Practical part
How to make a Service and distribute it with the Fluence network
This section aims to show how a service can be created from scratch and then deployed to the Fluence network. We will start with a discussion of FCE – special runtimes that designed to run multi-module Wasm applications with help of interface-types. Then we will create several simple services and discuss how to compile, run locally, and debug them with our tooling. Finally, we will deploy these services to Fluence nodes to use them next by the front-end application.
Speakers: Mikhail Voronov, Dmitry Shakhtarin; up to 40 min
Coffee break;10-15 min
Building a front-end for a p2p app
We’ve learned about the Fluence network and how it works. We’ve developed a service and deployed it onto a node. We’ve learned how to use Aquamarine to interact with services. Now is the time to write a front-end application.
Now we will demonstrate the process of making a web application with Fluence JS SDK. We will start with an empty create-react-app project and work our way towards the fully functional solution. By the end of this talk, we will develop a text editor, which synchronizes it’s state and the user online status with collaborators over Fluence p2p network. The application will be interacting with two minimalistic services pre-deployed to Fluence: user-list and history, but all of the features will be implemented on client-side without any need to modify existing software. Expect a lot frontend and a lot of code in TypeScript!
Speaker: Pavel Murgyin; 20 min
Aquamarine under the hood
We’ve seen the theory behind Aquamarine, and how it can be used to build apps. In this section, I’ll review the AIR language that is used to program distributed backends running on Aquamarine. We’ll dive into the possibilities of the language, and some of the patterns that emerged from our experience of writing AIR scripts.
Speaker: Alexey Pyshnenko; 20 min
Questions? Use the OAF contact form.
