- Nuclear Fission Apparatus
- Fision Go
- Fission Application
- Fission Applications
- Fission App Store
- Rogue Amoeba Fission
- Hotwire Fision
A short history of nuclear fission This article is more than 4 years old An Italian physicist, Enrico Fermi, was the first to achieve it but just recently nuclear fission’s popularity has been. . Fission now offers full Dark Mode support, with a “Match System” option that uses the Dark theme when your Mac is in Dark Mode, and the Light theme when in Light Mode. You can also still select your desired theme manually, right in Fission's Preferences window. Several major improvements have been made to Fission's waveform drawing. Fission – App Landing Page – PSD Web Template. Fission is a fully featured PSD template for creating beautiful landing pages, fast. Homepage – Dark. With this modern clean design you will get two stunning homepages with dark and light versions. This section walks through working with functions, for controlling execution of functions please refer to Controlling Function Execution Create a function Before creating a function, you’ll need an environment; read environments if you haven’t already. Let’s create an environment for our function. $ fission env create -name node -image fission/node-env Let’s create a simple code.
This section walks through working with functions, for controlling execution of functions please refer to Controlling Function Execution
Create a function
Before creating a function, you’ll need an environment; read environments if you haven’t already.
Let’s create an environment for our function. Eazydraw 9 5 2 player games.
Let’s create a simple code snippet in NodeJS which will output the string
'Hello, world!'
:Let’s create this function on the cluster.This only registers the function with Fission, it doesn’t run it yet.
Next, let’s create a route for the function which can be used for making HTTP requests:
Setup FISSION_ROUTER environment variable if you haven’t already.
When you hit this function’s URL, you get the expected response:
You can also create a function with executor type “newdeploy” and provide the minimum and maximum number of instances of the function.
View & update function source code
You can look at the source code associated with given function:
Let’s say you want to update the function to output “Hello Fission” instead of “Hello world”.
You can update the source file and update the source code for function:
Let’s verify that the function now responds with a different outputthan it did earlier:
Test and debug function
You can run a function using the test command. If the function call succeeds, it will output the function’s response:
But if there is an error in the function’s execution (it returns HTTP >= 300), then the logs of function execution are displayed:
You can also look at function execution logs explicitly:
Nuclear Fission Apparatus
Fission builds & compiled artifacts
Most real world functions will require more than one source files.It is also easier to simply provide source files and let Fission take care of building from source files.Fission provides first class support for building from source as well as using compiled artifacts to create functions.
You can attach the source/deployment packages to a function or explicitly create packages and use them across functions.Check documentation for package for more information.
Building functions from source
Let’s take a simple python function which has dependency on a python pyyaml module.We can specify the dependencies in requirements.txt and a simple command to build from source.The tree structure of directory looks like:
And the file contents:
Make sure the
build.sh
file is executable:You first need to create an environment with environment image and python-builder image specified:
Now let’s zip the directory containing the source files and create a function with source package:
Once we create the function, the build process is started.You can check logs of the builder in fission-builder namespace:
Once the build has succeeded, you can hit the function URL to test the function:
If you’re using Fission with source code, be sure to read about the recommended development workflow.
Using compiled artifacts with Fission
In some cases you have a pre-built deployment package which you need to deploy to Fission.For this example let’s use a simple python file as a deployment package but in practice it can be any other compiled package.
We will use a simple python file in a directory and turn it into a deployment package:
Let’s use the deployment package to create a function and route and then test it.
View function information
You can retrieve metadata information of a single function or list all functions to look at basic information of functions:
Last modified September 23, 2020: Markdown lint reformat (#218) (db2e794)
My name is Daniel, and I'm the newest member of the Fission team. I'm based near Springfield, Missouri, smack dab in the center of the Ozarks (recently made famous by the Netflix show, which is kinda like my life but with money laundering instead of unit tests). When I'm not working on building tools for the decentralized web, you can catch me reading cool books (currently reading), listening to music (currently listening), or rock climbing (my weekend plans).
Here at Fission, we've been hard at working cooking up cool new experiments with IPFS. IPFS's content-based addressing which gives us a flat, universal namespace to store files and other data prompts us to think differently about how we build and deploy software. This leads us to build prototypes and experiments, which help us:
• Ideate projects that either we or another team can expand upon
• Test and calibrate the tools we build for real world hands-on usage
• Prompt the creation of new libraries/technologies
Our most recent application came from a simple question that we asked: if my preferences are generally the same across apps, why do I need to fill out that same information in every app?
Introducing IPFS Portable User Settings — a completely client side application that allows you to update your preferences over IPFS and take them with you wherever you go.
Here at Fission, we've been hard at working cooking up cool new experiments with IPFS. IPFS's content-based addressing which gives us a flat, universal namespace to store files and other data prompts us to think differently about how we build and deploy software. This leads us to build prototypes and experiments, which help us:
• Ideate projects that either we or another team can expand upon
• Test and calibrate the tools we build for real world hands-on usage
• Prompt the creation of new libraries/technologies
Our most recent application came from a simple question that we asked: if my preferences are generally the same across apps, why do I need to fill out that same information in every app?
Introducing IPFS Portable User Settings — a completely client side application that allows you to update your preferences over IPFS and take them with you wherever you go.
Play around with the live demo
Background
Fision Go
While the emerging decentralized web and the web of yesteryear differ in many ways, one way to think about it is as a difference in user model. The web2.0 user data model is company (or platform)-centric. This involves locking your data in monolithic company-owned databases, with the end result being that your identity is fragmented and duplicated across a variety of corporate silos. Web3 brings with it a new way of conceptualizing data: a user-centric data model. In this model, a user owns their data and that data can only be read/edited by them and trusted people and apps. Apps take on a different function: they exist as 'windows' that a user grants permissions to view or make edits to certain attributes of their data.
Often, the benefits of web3 technology are put in reactionary terms. That is, it's reacting to the overreaches/missteps of the current corporate stewards of the internet: censorship, sloppy or malicious use of user data, temporality (will I be able to see my photos on Facebook in 25 years? my archived emails on Gmail?), and so on.
One thing that we aim to do at Fission is not only address the failings of web2, but also create positive reasons to make the jump to web3.
Often, the benefits of web3 technology are put in reactionary terms. That is, it's reacting to the overreaches/missteps of the current corporate stewards of the internet: censorship, sloppy or malicious use of user data, temporality (will I be able to see my photos on Facebook in 25 years? my archived emails on Gmail?), and so on.
One thing that we aim to do at Fission is not only address the failings of web2, but also create positive reasons to make the jump to web3.
Decentralized apps should be fun and easy for developers to create, and exciting for users to adopt because they offer features not possible in the old web. This was our motivation when developing our Portable User Settings. We wanted to give the intuition behind some of what's possible with web3 and a technical demo that a more robust version could be based on.
We also wanted to make this app completely p2p. No HTTP gateways required here! If your browser is IPFS-enabled and you're running a local daemon, the app connects to that daemon. If not, it gracefully sets up an in-browser instance of
We also wanted to make this app completely p2p. No HTTP gateways required here! If your browser is IPFS-enabled and you're running a local daemon, the app connects to that daemon. If not, it gracefully sets up an in-browser instance of
js-ipfs
.There are lots of directions this could go. Maybe we want to enable universal dark mode so that all the websites you browse respect your global dark mode setting? Leave a comment on what portable user setting you'd like to see in the world.
Technical Results
This project yielded not only a pretty neat demo, but also some useful technical offshoots:
get-ipfs
One of the biggest issues that developers can face when trying to make use of the decentralized web is the high barrier to entry. We wrapped our IPFS fallback functionality into it's own package: get-ipfs. This is your new one-stop shop for loading an IPFS instance into a webpage. It's as simple as
Fission JavaScript Client
This app was also our first time using the Fission JavaScript client in the wild. While adding/getting is done P2P, requests to pin must be sent over HTTP. The library, however, has all the functionality you need to make IPFS-enabled apps over HTTP. Check out the library and see what cool uses you can come up with!
Hosted IPFS Node
While we were already hosting an IPFS node, our hosted node is now much more robust. It's capable of handling secure websocket connects (so it can talk to in-browser
Again, checkout the demo here, or keep reading to find out how to build and host your own!
get-ipfs
One of the biggest issues that developers can face when trying to make use of the decentralized web is the high barrier to entry. We wrapped our IPFS fallback functionality into it's own package: get-ipfs. This is your new one-stop shop for loading an IPFS instance into a webpage. It's as simple as
const ipfs = await getIpfs()
and you can make direct P2P use of the decentralized web in your webapp. Give it a go and let us know how it works for you!Fission JavaScript Client
This app was also our first time using the Fission JavaScript client in the wild. While adding/getting is done P2P, requests to pin must be sent over HTTP. The library, however, has all the functionality you need to make IPFS-enabled apps over HTTP. Check out the library and see what cool uses you can come up with!
Hosted IPFS Node
While we were already hosting an IPFS node, our hosted node is now much more robust. It's capable of handling secure websocket connects (so it can talk to in-browser
js-ipfs
nodes!) and stores data in S3. Check out the walkthrough we posted for setting up your own IPFS node on AWS!Again, checkout the demo here, or keep reading to find out how to build and host your own!
Run/Deploy your own app
Fork the repo
Note: This is only necessary if you are planning on deploying your own user settings app. If you just want to play around locally, you can simply clone the repository.
Click 'Fork' in the upper-right corner of the repository.
Click 'Fork' in the upper-right corner of the repository.
Clone the repo locally
In your terminal, clone the
ipfs-user-settings
repo:Setup environment
The environment variables are optional, but will need to be setup for the best user experience.
First, create a
.env
file in the root of the repository:touch .env
Your
.env
will end up looking something like this:Let's walk through what each of those variables will do.
REACT_APP_DEFAULT_CID
: the cid that contains the default settings that you want a new user to see. You can set it to the above value for our recommended defaults (or leave it blank and it will default to that).**Edited this section to reflect recent changes**
Note: if you use a custom node, it must be interoperable with
REACT_APP_BOOTSTRAP_NODE_TCP
: the multiaddr of the ipfs node that you would like the user's node to connect to through tcp (for instance with a local daemon through ipfs companion). You can set it to the above value to connect to the IPFS node that Fission hosts (or leave it blank and it will default to that).REACT_APP_BOOTSTRAP_NODE_WSS
: the multiaddr of the ipfs node that you would like the user's node to connect to through wss (if the user does not have an ipfs-enabled browser and falls back to an in-browser js-ipfs daemon). You can set it to the above value to connect to the IPFS node that Fission hosts (or leave it blank and it will default to that). Note: if you use a custom node, it must be interoperable with
js-ipfs
. This means that it either needs to connect via WebRTC or Secured Websockets (notice the wss
in the above multiaddr).REACT_APP_INTERPLANETARY_FISSION_..
: the last three variables are your provisioned account information for using the Fission web-api. These are used for pinning content to the Fission IPFS node so that content will stay online even after a user goes offline. If you leave them blank, the webapp will not pin user content. At the moment, these can be obtained by joining the Fission Heroku add-on alpha. If you've tried out our earlier photo gallery demo, you can use the same credentials here, otherwise follow that tutorial to provision a username and passwordRun the app locally
First install dependencies:
npm install
Then run the app:
npm run start
Fission Application
This will open up a page in your browser at
http://localhost:3000
!Play around a bit! Try changing your settings, saving it, and loading past CIDs.
Build app
In order for your app to build with the correct internal links, you'll need to change the homepage:
Open
Open
package.json
and change the homepage
to the url where this site will be hosted ($YOUR_USERNAME.github.io/ipfs-user-settings
).Build the app:
npm run build
Fission Applications
Deploy app
Deploy with your favorite tool: Heroku, GitHub pages, etc. Or if you're reading this a month from now, use the new 'Fission Live' tool ?
We've included a deployment command for GitHub pages.
We've included a deployment command for GitHub pages.
Fission App Store
First, make sure that your repository is set as the git remote.
This won't work if it's still set to
This won't work if it's still set to
fission-suite
.Rogue Amoeba Fission
Run:
git remote -v
and ensure that that the url next to remote is https://github.com/$YOUR_USERNAME/ipfs-user-settings.git
If you forked the repo earlier, this should be fine. If you do need to change your remote, just run
git remote set origin https://github.com/$YOUR_USERNAME/ipfs-user-settings.git
Deploy the app:
npm run deploy
Hotwire Fision
Now open your browser to
Let us know how it goes! We're always eager to hear any feedback so come join the conversation on our forum, Discord, or GitHub.
$YOUR_USERNAME.github.io/ipfs-user-settings
to see your site up and running!Let us know how it goes! We're always eager to hear any feedback so come join the conversation on our forum, Discord, or GitHub.