Ethereum Classic is currently a speculative currency.
Understand how crypto{currency, contract} users organize themselves, then build a set of development tools that compliment their workflow and provide a means for them to sell their work.
This will assist in evolving from a speculative currency to utilitarian currency
Supply and demand isn't so interesting
What's more interesting is how each organization structures itself.
- Frederic Laloux
Laloux Culture Model
Every level up unlocks an order of magnitude in power
Reason for evolution
Instability of fear based power structures could not accomplish long term projects
Reason for evolution
Entrenched Amber organizations were unable to adapt to changing conditions
People feel the profit motive is not fulfilling enough and often become disengaged with the organization's view of them as cogs in a machine
Reason for evolution
2013 Gallup poll showed some 70% were disengaged
People are seeking more meaning in their work
Green hits it's limit when consensus building results in overly slow decision making
Reason for evolution
The hierarchical structures still existing in Green begin to conflict with peoples' desires to have greater autonomy
Cryptocurrency holders (especially the programmers) have the right conditions to form into a sprawling Teal community
Cryptocurrency can push Teal further
organizations which design systems ... are constrained to produce designs which are copies of the communication structures of these organizations.
— M. Conway
If the parts of an organization (e.g., teams, departments, or subdivisions) do not closely reflect the essential parts of the product, or if the relationship between organizations do not reflect the relationships between product parts, then the project will be in trouble... Therefore: Make sure the organization is compatible with the product architecture.
— James O. Coplien and Neil B. Harrison
Therefore: Make sure the organization is compatible with the product architecture.
Therefore: Make sure the product architecture is compatible with a decentralized (Teal) community.
An object whose parts, at infinitely many levels of magnification, appear geometrically similar to the whole.
The NoFlo IDE
flow-based programming (FBP) is a programming paradigm that defines applications as networks of "black box" processes, which exchange data across predefined connections by message passing, where the connections are specified externally to the processes. These black box processes can be reconnected endlessly to form different applications without having to be changed internally.
- Wikipedia
Flow-based Programming is a particular form of dataflow programming based on bounded buffers, information packets with defined lifetimes, named ports, and separate definition of connections.
- Wikipedia
This is an "Agent"
It does one thing, and does it well
Read File
It reads a file's contents
Classical UNIX philosophy
This is a named port
path
Read File
A port receives data via a bounded buffer
#[derive(Clone, Debug)]
pub struct FsPath(pub String);
We call it an "Edge"
path
Read File
#[derive(Clone, Debug)]
pub struct FsPath(pub String);
text
error
#[derive(Clone, Debug)]
pub struct FsFileError (pub String);
#[derive(Debug, Clone)]
pub enum FsFileDesc {
Start(String),
Text(String),
End(String),
}
#[macro_use]
extern crate rustfbp;
use std::fs::File;
use std::io::BufReader;
use std::io::BufRead;
agent! {
input(path: FsPath),
output(text: FsFileDesc, error: FsFileError),
fn run(&mut self) -> Result<Signal> {
// Get the path
let mut path = self.input.path.recv()?.0;
let file = match File::open(&path) {
Ok(file) => { file },
Err(_) => {
let _ = self.output.error.send(FsFileError(path));
return Ok(End);
}
};
// Send start
self.output.text.send(FsFileDesc::Start(path.clone()))?;
// Send lines
let file = BufReader::new(&file);
for line in file.lines() {
self.output.text.send(FsFileDesc::Text(line?))?;
}
// Send stop
self.output.text.send(FsFileDesc::End(path))?;
Ok(End)
}
}
Contents of the "Read File" agent
All logic is kept in one place and not spread out all over the code base.
Making the code easier to reason about.
path
Read File
text
#[derive(Debug, Clone)]
pub enum FsFileDesc {
Start(String),
Text(String),
End(String),
}
Print File
input
This is a contract between two nodes
Data description can be arbitrarily deep scaling up to describe complex interactions between organizations, not only simple inter-node descriptions
path
Read File
text
Print File
input
path
Print File
This is a Subgraph
A Subgraph hides implementation details and allows for powers of abstraction
Supports arbitrarily deep nesting
path
Read File
text
Print File
input
path
Subgraph
path
Read File
Agent
Allowing us to use familiar Graph Theory terminology "Nodes and Edges"
#[derive(Clone, Debug)]
pub struct FsPath(pub String);
A Subgraph contains other Subgraphs and/or Agents
An Agent contains code
An Edge passes data
Flow-based Programming is reusable in nature
But each node has a life cycle and it becomes hard to manage the life cycles of a thousand nodes
We need to make every node reproducible!
Reproducibility is essential for the Scientific Method
Every dependency is deterministic so it's a pleasure to reason about
{ agent, edges, mods, pkgs }:
agent {
src = ./.;
edges = with edges.rs; [ FsPath FsFileDesc FsFileError ];
mods = with mods.rs; [ rustfbp ];
osdeps = with pkgs; [ openssl ];
}
We use the Nix Package manager.
We now have a Reproducible, Reusable and Composable system.
Many consider this the Holy Grail in the software world.
Domain Specialists
Programmers
Read File
Print File
Subgraphs
Snap subgraphs together like lego. They don't need programming knowledge
Read File
Agent
#[macro_use]
extern crate rustfbp;
use std::fs::File;
use std::io::BufReader;
use std::io::BufRead;
agent! {
input(path: FsPath),
output(text: FsFileDesc, error: FsFileError),
fn run(&mut self) -> Result<Signal> {
// Get the path
let mut path = self.input.path.recv()?.0;
let file = match File::open(&path) {
Ok(file) => { file },
Err(_) => {
let _ = self.output.error.send(FsFileError(path));
return Ok(End);
}
};
// Send start
self.output.text.send(FsFileDesc::Start(path.clone()))?;
// Send lines
let file = BufReader::new(&file);
for line in file.lines() {
self.output.text.send(FsFileDesc::Text(line?))?;
}
// Send stop
self.output.text.send(FsFileDesc::End(path))?;
Ok(End)
}
}
Agent Source Code
#[macro_use]
extern crate rustfbp;
use std::fs::File;
use std::io::BufReader;
use std::io::BufRead;
agent! {
input(path: FsPath),
output(text: FsFileDesc, error: FsFileError),
fn run(&mut self) -> Result<Signal> {
// Get the path
let mut path = self.input.path.recv()?.0;
let file = match File::open(&path) {
Ok(file) => { file },
Err(_) => {
let _ = self.output.error.send(FsFileError(path));
return Ok(End);
}
};
// Send start
self.output.text.send(FsFileDesc::Start(path.clone()))?;
// Send lines
let file = BufReader::new(&file);
for line in file.lines() {
self.output.text.send(FsFileDesc::Text(line?))?;
}
// Send stop
self.output.text.send(FsFileDesc::End(path))?;
Ok(End)
}
}
Free and Open Source
OR
Time out Free and Open Source
#[macro_use]
extern crate rustfbp;
use std::fs::File;
use std::io::BufReader;
use std::io::BufRead;
agent! {
input(path: FsPath),
output(text: FsFileDesc, error: FsFileError),
fn run(&mut self) -> Result<Signal> {
// Get the path
let mut path = self.input.path.recv()?.0;
let file = match File::open(&path) {
Ok(file) => { file },
Err(_) => {
let _ = self.output.error.send(FsFileError(path));
return Ok(End);
}
};
// Send start
self.output.text.send(FsFileDesc::Start(path.clone()))?;
// Send lines
let file = BufReader::new(&file);
for line in file.lines() {
self.output.text.send(FsFileDesc::Text(line?))?;
}
// Send stop
self.output.text.send(FsFileDesc::End(path))?;
Ok(End)
}
}
Agent Source Code
May publish their source code
May choose to adopt a 2~3 year timeout license. Such that the code automatically publishes after you've made a profit
Programmers
Read File
Bob
Print File
Alice
Read File
Print File
Carol
Non-programmer Domain Specialists
End User
Print File
Dave
Making it easy to use any currency and associated applications